hoodoo 1.12.4 → 1.13.0

data/lib/hoodoo/presenters/types/array.rb

@@ -11,6 +11,52 @@ module Hoodoo
       #
       attr_accessor :properties
 
+      # Initialize an Array instance with the appropriate name and options.
+      #
+      # +name+::    The JSON key.
+      # +options+:: A +Hash+ of options, e.g. <tt>:required => true,
+      #             :type => :enum, :field_from => [ 1, 2, 3, 4 ]</tt>. If
+      #             a +:type+ field is present, the Array contains atomic
+      #             types of the given kind. Otherwise, either pass a
+      #             block with inner schema DSL calls describing complex
+      #             array entry schema, or nothing for no array content
+      #             validation. If a block _and_ +:type+ option are
+      #             passed, the block is used and option ignored.
+      #
+      def initialize( name, options = {} )
+        super( name, options )
+
+        if options.has_key?( :type )
+
+          # Defining a property via "#property" adds it to the @properties
+          # array, but handling of simple Types in array validation and
+          # rendering is too different from complex types to use the same
+          # code flow; we need the property to be independently used, so
+          # extract it into its own instance variable and delete the item
+          # from @properties.
+          #
+          value_klass     = type_option_to_class( options[ :type ] )
+          random_name     = Hoodoo::UUID.generate()
+          @value_property = property( random_name,
+                                      value_klass,
+                                      extract_field_prefix_options_from( options ) )
+
+          @properties.delete( random_name )
+
+          # This is approaching a blunt hack. Without it, validation errors
+          # will result in e.g. "fields[1].cd2f0a15ec8e4bd6ab1964b25b044e69"
+          # in error messages. By using nil, the validation code's JSON path
+          # array to string code doesn't include the item, giving the
+          # desired result. In addition, the base class Field#render code
+          # has an important check for non-nil but empty and bails out, but
+          # allows the nil name case to render simple types as expected. A
+          # delicate / fragile balance of nil-vs-empty arises.
+          #
+          @value_property.name = nil
+
+        end
+      end
+
       # Check if data is a valid Array and return a Hoodoo::Errors instance.
       #
       def validate( data, path = '' )
@@ -18,8 +64,12 @@ module Hoodoo
         return errors if errors.has_errors? || ( ! @required && data.nil? )
 
         if data.is_a?( ::Array )
-          # No array entry schema? No array entry validation, then.
-          unless @properties.nil?
+
+          # A block which defined properties for this instance takes
+          # precedence; then check for a ":type" option via "@@value_property"
+          # stored in the constructor; then give up and do no validation.
+          #
+          if @properties.nil? == false && @properties.empty? == false
             data.each_with_index do | item, index |
               @properties.each do | name, property |
                 rdata = ( item.is_a?( ::Hash ) && item.has_key?( name ) ) ? item[ name ] : nil
@@ -27,7 +77,13 @@ module Hoodoo
                 errors.merge!( property.validate( rdata, indexed_path ) )
               end
             end
+          elsif @value_property.nil? == false
+            data.each_with_index do | item, index |
+              indexed_path = "#{ full_path( path ) }[#{ index }]"
+              errors.merge!( @value_property.validate( item, indexed_path ) )
+            end
           end
+
         else
           errors.add_error(
             'generic.invalid_array',
@@ -66,11 +122,7 @@ module Hoodoo
 
         # ...then look at rendering the input entries of 'data' into 'array'.
 
-        if @properties.nil?
-          # Must modify existing instance of 'array', so use 'push()'
-          array.push( *data )
-
-        else
+        if @properties.nil? == false && @properties.empty? == false
           data.each do | item |
 
             # We have properties defined so array values (in "item") must be
@@ -98,6 +150,21 @@ module Hoodoo
             # Must modify existing instance of 'array', so use 'push()'
             array.push( rendered )
           end
+
+        elsif @value_property.nil? == false
+          data.each do | item |
+            subtarget = {}
+            @value_property.render( item, subtarget )
+            rendered = subtarget.empty? ? nil : read_at_path( subtarget, path ).values.first
+
+            # Must modify existing instance of 'array', so use 'push()'
+            array.push( rendered )
+          end
+
+        else
+          # Must modify existing instance of 'array', so use 'push()'
+          array.push( *data )
+
         end
       end
 

data/lib/hoodoo/presenters/types/field.rb

@@ -71,7 +71,7 @@ module Hoodoo
       # Returns the full path array that was used (a clone of +@path+).
       #
       def render( data, target )
-        return if @name.empty?
+        return if @name.nil? == false && @name.empty?
 
         root  = target
         path  = @path.clone

data/lib/hoodoo/presenters/types/hash.rb

@@ -57,23 +57,30 @@ module Hoodoo
           raise "Can't use \#keys and then \#key in the same hash definition - use one or the other"
         end
 
+        @specific   = true
+        value_klass = block_given?               ?
+                      Hoodoo::Presenters::Object :
+                      type_option_to_class( options.delete( :type ) )
+
         # If we're defining specific keys and some of those keys have fields
-        # with defaults, we need to merge those up to provide a whole-key
+        # with defaults, we need to merge those up to provide a whole-Hash
         # equivalent default. If someone renders an empty hash they expect a
         # specific key with some internal defaults to be rendered; doing this
         # amalgamation up to key level is the easiest way to handle that.
-
-        if options.has_key?( :default )
-          @has_default = true
-
-          @default    ||= {}
-          @default.merge!( Hoodoo::Utilities.stringify( options[ :default ] ) )
+        #
+        if options.has_key?( :default ) || options.has_key?( :field_default )
+          @has_default     = true
+          @default       ||= {}
+          @default[ name ] = options[ :default ] || options[ :field_default ]
         end
 
-        @specific = true
-
-        klass = block_given? ? Hoodoo::Presenters::Object : Hoodoo::Presenters::Field
-        prop  = property( name, klass, options, &block )
+        prop = property( name,
+                         value_klass,
+                         Hoodoo::Utilities.deep_merge_into(
+                           options,
+                           extract_field_prefix_options_from( options )
+                         ),
+                         &block )
 
         if prop && prop.respond_to?( :is_internationalised? ) && prop.is_internationalised?
           internationalised()
@@ -148,12 +155,20 @@ module Hoodoo
         end
 
         @specific = false
+        key_klass = options.has_key?( :length ) ?
+                    Hoodoo::Presenters::String  :
+                    Hoodoo::Presenters::Text
+
+        property( 'keys', key_klass, options )
 
-        klass = options.has_key?( :length ) ? Hoodoo::Presenters::String : Hoodoo::Presenters::Text
-        property('keys', klass, options)
+        value_klass = block_given?               ?
+                      Hoodoo::Presenters::Object :
+                      type_option_to_class( options[ :type ] )
 
-        klass = block_given? ? Hoodoo::Presenters::Object : Hoodoo::Presenters::Field
-        prop  = property( 'values', klass, {}, &block )
+        prop = property( 'values',
+                         value_klass,
+                         extract_field_prefix_options_from( options ),
+                         &block )
 
         if prop && prop.respond_to?( :is_internationalised? ) && prop.is_internationalised?
           internationalised()
@@ -237,7 +252,7 @@ module Hoodoo
                     keys_property.rename( key )
                   values_property.rename( key )
 
-                  errors.merge!(   keys_property.validate( key, local_path ) )
+                  errors.merge!(   keys_property.validate(   key, local_path ) )
                   errors.merge!( values_property.validate( value, local_path ) )
                 end
 

data/lib/hoodoo/utilities/utilities.rb

@@ -300,6 +300,7 @@ module Hoodoo
     # 8601 subset date and time, else +false+.
     #
     def self.valid_iso8601_subset_datetime?( str )
+      return false unless str.is_a?( String ) || str.is_a?( Symbol )
 
       # Relies on Ruby evaluation behaviour and operator precedence - "'foo'
       # && true" => true, but "true && 'foo'" => 'foo'. Don't use "and" here!
@@ -324,6 +325,7 @@ module Hoodoo
     # subset date, else +false+.
     #
     def self.valid_iso8601_subset_date?( str )
+      return false unless str.is_a?( String ) || str.is_a?( Symbol )
 
       # Same reliance as 'valid_iso8601_subset_datetime'?.
 

data/lib/hoodoo/version.rb

@@ -12,6 +12,6 @@ module Hoodoo
   # The Hoodoo gem version. If this changes, ensure that the date in
   # "hoodoo.gemspec" is correct and run "bundle install" (or "update").
   #
-  VERSION = '1.12.4'
+  VERSION = '1.13.0'
 
 end

data/spec/presenters/base_dsl_spec.rb

@@ -108,4 +108,33 @@ describe Hoodoo::Presenters::BaseDSL do
       }.not_to raise_error
     end
   end
+
+  describe '#type_option_to_class' do
+    it 'should raise an error for unrecognised types' do
+      expect {
+        klass = Hoodoo::Presenters::Object.new
+        klass.send( :type_option_to_class, :foo )
+      }.to raise_error(RuntimeError, "Unsupported 'type' option value of 'foo' in Hoodoo::Presenters::BaseDSL")
+    end
+  end
+
+  describe '#extract_field_prefix_options_from' do
+    it 'should extract options' do
+      data = {
+        :default => :foo,
+        :field_one => :one,
+        'field_two' => :two,
+        'field_three-three three' => { :three => 3 }
+      }
+
+      klass  = Hoodoo::Presenters::Object.new
+      result = klass.send( :extract_field_prefix_options_from, data )
+
+      expect( result ).to( eql( {
+        :one => :one,
+        :two => :two,
+        :'three-three three' => { :three => 3 }
+      } ) )
+    end
+  end
 end

data/spec/presenters/types/array_spec.rb

@@ -29,6 +29,8 @@ describe Hoodoo::Presenters::Array do
     end
   end
 
+  ############################################################################
+
   describe '#validate' do
     it 'should return [] when valid array' do
       expect(@inst.validate([]).errors).to eq([])
@@ -37,12 +39,12 @@ describe Hoodoo::Presenters::Array do
     it 'should return correct error when data is not a array' do
       errors = @inst.validate('asckn')
 
-      err = [  {'code'=>"generic.invalid_array", 'message'=>"Field `one` is an invalid array", 'reference'=>"one"}]
+      err = [  {'code'=>'generic.invalid_array', 'message'=>'Field `one` is an invalid array', 'reference'=>'one'}]
       expect(errors.errors).to eq(err)
     end
 
     it 'should return correct error with non array types' do
-      err = [  {'code'=>"generic.invalid_array", 'message'=>"Field `one` is an invalid array", 'reference'=>"one"}]
+      err = [  {'code'=>'generic.invalid_array', 'message'=>'Field `one` is an invalid array', 'reference'=>'one'}]
 
       expect(@inst.validate('asckn').errors).to eq(err)
       expect(@inst.validate(34534).errors).to eq(err)
@@ -58,14 +60,14 @@ describe Hoodoo::Presenters::Array do
     it 'should return error when required and absent' do
       @inst.required = true
       expect(@inst.validate(nil).errors).to eq([
-        {'code'=>"generic.required_field_missing", 'message'=>"Field `one` is required", 'reference'=>"one"}
+        {'code'=>'generic.required_field_missing', 'message'=>'Field `one` is required', 'reference'=>'one'}
       ])
     end
 
     it 'should return correct error with path' do
       errors = @inst.validate('scdacs','ordinary')
       expect(errors.errors).to eq([
-        {'code'=>"generic.invalid_array", 'message'=>"Field `ordinary.one` is an invalid array", 'reference'=>"ordinary.one"}
+        {'code'=>'generic.invalid_array', 'message'=>'Field `ordinary.one` is an invalid array', 'reference'=>'ordinary.one'}
       ])
     end
 
@@ -75,7 +77,7 @@ describe Hoodoo::Presenters::Array do
 
       errors = TestPresenterArray.validate(data)
       expect(errors.errors).to eq([
-        {'code'=>"generic.required_field_missing", 'message'=>"Field `an_array` is required", 'reference'=>"an_array"},
+        {'code'=>'generic.required_field_missing', 'message'=>'Field `an_array` is required', 'reference'=>'an_array'},
       ])
 
     end
@@ -104,8 +106,8 @@ describe Hoodoo::Presenters::Array do
 
       errors = TestPresenterArray.validate(data)
       expect(errors.errors).to eq([
-        {'code'=>"generic.invalid_integer", 'message'=>"Field `an_array[1].an_integer` is an invalid integer", 'reference'=>"an_array[1].an_integer"},
-        {'code'=>"generic.invalid_datetime", 'message'=>"Field `an_array[2].a_datetime` is an invalid ISO8601 datetime", 'reference'=>"an_array[2].a_datetime"},
+        {'code'=>'generic.invalid_integer', 'message'=>'Field `an_array[1].an_integer` is an invalid integer', 'reference'=>'an_array[1].an_integer'},
+        {'code'=>'generic.invalid_datetime', 'message'=>'Field `an_array[2].a_datetime` is an invalid ISO8601 datetime', 'reference'=>'an_array[2].a_datetime'},
       ])
     end
 
@@ -125,6 +127,8 @@ describe Hoodoo::Presenters::Array do
     end
   end
 
+  ############################################################################
+
   describe '#render' do
     it 'renders correctly with whole-array default (1)' do
       data = nil
@@ -186,7 +190,7 @@ describe Hoodoo::Presenters::Array do
           }
         ],
         'a_default_array' => [ { 'an_integer' => 42 }, { 'some_array_text' => 'hello' } ],
-        'an_enum' => "one"
+        'an_enum' => 'one'
       })
     end
 
@@ -218,7 +222,7 @@ describe Hoodoo::Presenters::Array do
           { 'an_integer' => 23 },
           { 'an_integer' => 42, 'a_datetime' => time },
         ],
-        'an_enum' => "one"
+        'an_enum' => 'one'
       })
     end
 
@@ -245,5 +249,238 @@ describe Hoodoo::Presenters::Array do
       })
     end
   end
+  class TestPresenterTypedArray < Hoodoo::Presenters::Base
+    schema do
+      array :array,     :type => :array
+      array :boolean,   :type => :boolean
+      array :date,      :type => :date
+      array :date_time, :type => :date_time
+      array :decimal,   :type => :decimal,   :field_precision => 2
+      array :enum,      :type => :enum,      :field_from      => [ :one, :two, :three ]
+      array :float,     :type => :float
+      array :integer,   :type => :integer
+      array :string,    :type => :string,    :field_length    => 4
+      array :tags,      :type => :tags
+      array :text,      :type => :text
+      array :uuid,      :type => :uuid
+      array :field
+    end
+  end
+
+  ############################################################################
+
+  ARRAY_DATA = {
+    'array'     => { :valid => [ [ 2, 3, 4 ]             ], :invalid => [ 4, { :one => 1 }                 ] },
+    'boolean'   => { :valid => [ true                    ], :invalid => [ 4.51, 'false'                    ] },
+    'date'      => { :valid => [ Date.today.iso8601      ], :invalid => [ Date.today, '23rd January 2041'  ] },
+    'date_time' => { :valid => [ DateTime.now.iso8601    ], :invalid => [ DateTime.now, '2017-01-27 12:00' ] },
+    'decimal'   => { :valid => [ BigDecimal.new(4.51, 2) ], :invalid => [ 4.51, '4.51'                     ] },
+    'enum'      => { :valid => [ 'one'                   ], :invalid => [ 'One', 1                         ] },
+    'float'     => { :valid => [ 4.51                    ], :invalid => [ BigDecimal.new(4.51, 2), '4.51'  ] },
+    'integer'   => { :valid => [ 4                       ], :invalid => [ '4'                              ] },
+    'string'    => { :valid => [ 'four'                  ], :invalid => [ 'toolong', 4, true               ] },
+    'tags'      => { :valid => [ 'tag_a,tag_b,tag_c'     ], :invalid => [ 4, true                          ] },
+    'text'      => { :valid => [ 'hello world'           ], :invalid => [ 4, true                          ] },
+    'uuid'      => { :valid => [ Hoodoo::UUID.generate() ], :invalid => [ '123456', 4, true                ] },
+    'field'     => { :valid => [ 4, '4', { :one => 1 }   ], :invalid => [                                  ] }
+  }
+
+  ARRAY_DATA.each do | field, values |
+    context '#render' do
+      values[ :valid ].each_with_index do | value, index |
+        it "renders correctly for '#{ field }' (#{ index + 1 })" do
+          data = { field => [ value, value, value ] }
+          expect( TestPresenterTypedArray.render( data ) ).to eq( data )
+        end
+      end
+    end
+
+    context '#validate' do
+      values[ :valid ].each_with_index do | value, index |
+        it "accepts a valid value for '#{ field }' (#{ index + 1 })" do
+          data = { field => [ value, value, value ] }
+          expect( TestPresenterTypedArray.validate( data ).errors.size ).to eql( 0 )
+        end
+      end
+
+      values[ :invalid ].each_with_index do | value, index |
+        it "rejects an invalid value for '#{ field }' (#{ index + 1 })" do
+          data = { field => [ value, value, value ] }
+          expect( TestPresenterTypedArray.validate( data ).errors.size ).to eql( 3 )
+        end
+      end
+    end
+  end
+
+  ############################################################################
+
+  context 'RDoc examples' do
+    context 'VeryWealthy' do
+      class TestHypotheticalCurrency < Hoodoo::Presenters::Base
+        schema do
+          string :currency_code, :length => 16
+          integer :precision
+        end
+      end
+
+      class TestVeryWealthy < Hoodoo::Presenters::Base
+        schema do
+          array :currencies, :required => true do
+            type TestHypotheticalCurrency
+            string :notes, :required => true, :length => 32
+          end
+        end
+      end
+
+      let( :valid_data ) do
+        {
+          'currencies' => [
+            {
+              'currency_code' => 'X_HOODOO',
+              'precision' => 2,
+              'notes' => 'A short note'
+            }
+          ]
+        }
+      end
+
+      context '#validate' do
+        it 'enforces a required array' do
+          data = {}
+
+          errors = TestVeryWealthy.validate( data ).errors
+
+          expect( errors.size ).to( eql( 1 ) )
+          expect( errors[ 0 ][ 'code'      ] ).to( eql( 'generic.required_field_missing' ) )
+          expect( errors[ 0 ][ 'reference' ] ).to( eql( 'currencies' ) )
+        end
+
+        it 'enforces a required array entry field' do
+          data = {
+            'currencies' => [ {} ]
+          }
+
+          errors = TestVeryWealthy.validate( data ).errors
+
+          expect( errors.size ).to( eql( 1 ) )
+          expect( errors[ 0 ][ 'code'      ] ).to( eql( 'generic.required_field_missing' ) )
+          expect( errors[ 0 ][ 'reference' ] ).to( eql( 'currencies[0].notes' ) )
+        end
+
+        it 'enforces an array entry field length' do
+          data = {
+            'currencies' => [
+              {
+                'notes' => 'This note is too long for the 32-character limit'
+              }
+            ]
+          }
+
+          errors = TestVeryWealthy.validate( data ).errors
+
+          expect( errors.size ).to( eql( 1 ) )
+          expect( errors[ 0 ][ 'code'      ] ).to( eql( 'generic.invalid_string' ) )
+          expect( errors[ 0 ][ 'reference' ] ).to( eql( 'currencies[0].notes' ) )
+        end
+
+        it 'is happy with valid data' do
+          expect( TestVeryWealthy.validate( valid_data() ).errors.size ).to( eql( 0 ) )
+        end
+      end
+
+      context '#render' do
+        it 'renders valid data' do
+          expect( TestVeryWealthy.render( valid_data() ) ).to( eql( valid_data() ) )
+        end
+      end
+    end
+
+    context 'UUIDCollection' do
+      class TestUUIDCollection < Hoodoo::Presenters::Base
+        schema do
+          array :uuids, :type => :uuid
+        end
+      end
+
+      let( :valid_data ) do
+        {
+          'uuids' => [
+            Hoodoo::UUID.generate(),
+            Hoodoo::UUID.generate(),
+            Hoodoo::UUID.generate()
+          ]
+        }
+      end
+
+      context '#validate' do
+        it 'validates entries' do
+          data = {
+            'uuids' => [
+              Hoodoo::UUID.generate(),
+              'not a UUID'
+            ]
+          }
+
+          errors = TestUUIDCollection.validate( data ).errors
+
+          expect( errors.size ).to( eql( 1 ) )
+          expect( errors[ 0 ][ 'code'      ] ).to( eql( 'generic.invalid_uuid' ) )
+          expect( errors[ 0 ][ 'reference' ] ).to( eql( 'uuids[1]' ) )
+        end
+      end
+
+      context '#render' do
+        it 'renders valid data' do
+          expect( TestUUIDCollection.render( valid_data() ) ).to( eql( valid_data() ) )
+        end
+      end
+    end
+
+    context 'DecimalCollection' do
+      class TestDecimalCollection < Hoodoo::Presenters::Base
+        schema do
+          array :numbers, :type => :decimal, :field_precision => 2
+        end
+      end
+
+      let( :valid_data ) do
+        {
+          'numbers' => [
+            BigDecimal.new( '42.55111' ), # Precision is FYI data generators, not the renderer :-/
+            BigDecimal.new( '42.4'     ),
+            BigDecimal.new( '42'       )
+          ]
+        }
+      end
+
+      context '#validate' do
+        it 'validates entries' do
+          data = {
+            'numbers' => [
+              BigDecimal.new( '42.21' ),
+              'not a decimal'
+            ]
+          }
+
+          errors = TestDecimalCollection.validate( data ).errors
+
+          expect( errors.size ).to( eql( 1 ) )
+          expect( errors[ 0 ][ 'code'      ] ).to( eql( 'generic.invalid_decimal' ) )
+          expect( errors[ 0 ][ 'reference' ] ).to( eql( 'numbers[1]' ) )
+        end
+      end
+
+      context '#render' do
+        it 'renders valid data' do
+
+          # Precision is FYI data generators, not the renderer so high
+          # precision BigDecimals are returned as-is in rendering :-/
+          #
+          expect( TestDecimalCollection.render( valid_data() ) ).to( eql( valid_data() ) )
+
+        end
+      end
+    end
+  end
 
 end