attributor 6.5 → 7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9242ef6d878ab79e69393d7bf31b6459873d39a8307c9dac0ea05ce8c4a01912
-  data.tar.gz: 0b2f333abe4957d1575df87c734c4f642274a83d50562059c33fb261154e44a5
+  metadata.gz: 5b5fc3c6809e4a0e21b21752683196ce018beafbb7d8b615f2217abbcb55b3c3
+  data.tar.gz: 55bba33e0b5ee71c581a029cfd3045c6f71ce5d1f578b2654d99f919626dcbc8
 SHA512:
-  metadata.gz: 48a0ea86f5550dd44b0d162ea96c1a98bbd7019955857f607817efe921fc4250c210e2591664d18a9388fd614d323547c83421b64ba678369c47d248423770ca
-  data.tar.gz: dcd17fa9b98e35d02e471ef340b641ba15ff4fafd6f05d5ac650204830ba7cc7a44feaf40b6a2386c660ab17d3b8d0b881d01d84c4a83a46fe41c6552a2ec74d
+  metadata.gz: f09888249f30f079afcbfbc09695cf828bed15d6c6b621b0ab5a55de086b740c74bfa33cfd4b75fa1c97650ccb0c7ceeb5850401af94a11619ea46b6c0aada33
+  data.tar.gz: b3876fbc0f432ff67fc0031234a4da8eea6b2b965d539a71f5a27ab615442cc8ae2420270a315a2d1461fb20d3f9aa7eae8619a1e7979f9f6cb73365d786cddd

data/CHANGELOG.md

@@ -2,6 +2,17 @@
 
 ## next
 
+## 7.0 (5/23/2023)
+- Support for loading "<digits>." strings in BigDecimal/Float types (These are formats supported by JS, Java ..)
+- Support for defining collections of types using a more terse DSL: T[]
+  - For example: Attributor::Integer[] is equivalent to Attributor::Collection.of(Attributor::Integer)
+  - It also caches these collection types when they are concrete (i.e., not constructable like Struct[], etc...)
+- Revamped the type and options inheritance (and :reference behavior) when defining attributes:
+  - The matrix of behavior is now fully defined, and all possible combinations of parameters are tested
+  - tightened up some error cases and messaging (i.e., cannot pass :reference unless there is a block, etc...)
+  - while technically this change is compatible, it might surface some errors in previous definitions that somehow
+    resolved things ambiguously (and now they will complain loudly). This is the reason for bumping the major version.
+
 ## 6.5 (1/19/2023)
 - Fix JSON schema reporting for BigDecimal types to be a string, with a format=bigdecimal
 

data/lib/attributor/dsl_compiler.rb

@@ -12,6 +12,7 @@ module Attributor
   class DSLCompiler
     attr_accessor :options, :target
 
+    include Attributor
     def initialize(target, **options)
       @target = target
       @options = options
@@ -33,6 +34,15 @@ module Attributor
 
     def attribute(name, attr_type = nil, **opts, &block)
       raise AttributorException, "Attribute names must be symbols, got: #{name.inspect}" unless name.is_a? ::Symbol
+      if opts[:reference]
+        raise AttributorException, ":reference option can only be used when defining blocks"  unless block_given? 
+        if opts[:reference] < Attributor::Collection
+          err = ":reference option cannot be a collection. It must be a concrete Struct-like type containing the attribute #{name} you are defining.\n"
+          location_file, location_line = block.source_location               
+          err += "The place where you are trying to define the attribute is here:\n#{location_file} line #{location_line}\n#{block.source}\n"
+          raise AttributorException, err
+        end
+      end
       target.attributes[name] = define(name, attr_type, **opts, &block)
     end
 
@@ -79,7 +89,6 @@ module Attributor
     # @api semiprivate
     def define(name, attr_type = nil, **opts, &block)
       example_given = opts.key? :example
-
       # add to existing attribute if present
       if (existing_attribute = attributes[name])
         if existing_attribute.attributes
@@ -87,40 +96,74 @@ module Attributor
           return existing_attribute
         end
       end
-
-      # determine inherited type (giving preference to the direct attribute options)
-      inherited_type = opts[:reference]
-      unless inherited_type
-        reference = options[:reference]
-        if reference && reference.respond_to?(:attributes) && reference.attributes.key?(name)
-          inherited_attribute = reference.attributes[name]
-          opts = inherited_attribute.options.merge(opts) unless attr_type
-          inherited_type = inherited_attribute.type
-          opts[:reference] = inherited_type if block_given?
+    
+      if attr_type.nil?
+        if block_given?
+          final_type, carried_options = resolve_type_for_block(name,  **opts, &block)
+        else
+          final_type, carried_options = resolve_type_for_no_block(name,  **opts)
         end
+      else
+        final_type = attr_type
+        carried_options = {}
       end
 
-      # determine attribute type to use
-      if attr_type.nil?
-        if block_given?
-          # Don't inherit explicit examples if we've redefined the structure 
-          # (but preserve the direct example if given here)
-          opts.delete :example unless  example_given
-          attr_type = if inherited_type && inherited_type < Attributor::Collection
-                        # override the reference to be the member_attribute's type for collections
-                        opts[:reference] = inherited_type.member_attribute.type
-                        Attributor::Collection.of(Struct)
-                      else
-                        Attributor::Struct
-                      end
-        elsif inherited_type
-          attr_type = inherited_type
+      final_opts = opts.dup
+      final_opts.delete(:reference) 
+      
+      # Possibly add a reference for block definitions (No reference for leaves)
+      final_opts.merge!(add_reference_to_block(name, opts)) if block_given?
+      final_opts = carried_options.merge(final_opts)
+      Attributor::Attribute.new(final_type, final_opts, &block)
+    end
+
+
+    def resolve_type_for_block(name,  **opts)
+      resolved_type = nil
+      carried_options = {}
+      ref = options[:reference]
+      if ref && ref.respond_to?(:attributes) && ref.attributes.key?(name)
+        type_from_ref = ref.attributes[name]&.type
+        resolved_type = type_from_ref < Attributor::Collection ? Attributor::Struct[] : Attributor::Struct
+      else
+        # Type for attribute with given name could not be determined from reference...or ther is not refrence: defaulting to Struct"
+        resolved_type = Attributor::Struct
+      end
+      [resolved_type, carried_options]
+    end
+
+    def resolve_type_for_no_block(name,  **opts)
+      resolved_type = nil
+      carried_options = {}
+      ref = options[:reference]
+      if ref && ref.respond_to?(:attributes) && ref.attributes.key?(name)
+        resolved_type = ref.attributes[name].type
+        carried_options = ref.attributes[name].options
+      else
+        message = "Type for attribute with name: #{name} could not be determined.\n"
+        if ref
+          message += "You are defining '#{name}' without a type, and the passed in :reference type (#{ref}) does not have an attribute named '#{name}'.\n" \
         else
-          raise AttributorException, "type for attribute with name: #{name} could not be determined"
+          message += "You are defining '#{name}' without a type, and there is no :reference type to infer it from (Did you forget to add the type?).\n" \
         end
+        message += "\nIf you are omiting a type thinking that would be inherited from the reference, make sure the right one is passed in," \
+          ", which has a #{name} defined, otherwise simply specify the type of the attribute you want.\n"
+        raise AttributorException, message
       end
+      [resolved_type, carried_options]
+    end
 
-      Attributor::Attribute.new(attr_type, opts, &block)
+    def add_reference_to_block(name, opts)
+      base_reference  = options[:reference]
+      if opts[:reference] # Direct reference specified in the attribute, just pass it to the block
+        {reference: opts[:reference]}
+      elsif( base_reference && base_reference.respond_to?(:attributes) && base_reference.attributes.key?(name))
+        selected_type = base_reference.attributes[name].type
+        selected_type = selected_type.member_attribute.type if selected_type < Attributor::Collection
+        {reference: selected_type}
+      else
+        {}
+      end
     end
   end
 end

data/lib/attributor/type.rb

@@ -4,6 +4,61 @@ module Attributor
   module Type
     extend ActiveSupport::Concern
 
+      # Memoized collection classes of specific type (by collection type)
+      # i.e., CSV is a Collection of String, which is different from a pure Collection (default)
+      # key = membertype class (i.e., String)
+      # value = Hash
+      #    key = concrete collection class: Attributor::Collection (default) or Attributor::CSV...
+      #   value = memoized constructed collection class of the given member type and collection type
+      # example: 
+      # String => { 
+      #   Attributor::Collection => Attributor::Collection.of(String), 
+      #   Attributor::CSV => Attributor::CSV.of(String)
+      # }
+      # It memoized them on in the base Type class, properly serializing access through a mutex
+      @_memoized_collection_classes = Hash.new do |h, k|
+        h[k] = {}
+      end
+      @_memoized_collection_classes_mutex = Mutex.new
+
+      class << self
+        attr_accessor :_memoized_collection_classes
+        def get_memoized_collection_class(member_class, collection_type=Attributor::Collection)
+          # No need to serialize on read, Ruby will ensure we can properly read what's there, even if it's being written
+          _memoized_collection_classes.dig(member_class,collection_type)
+        end
+        def set_memoized_collection_class(klass, member_class, collection_type=Attributor::Collection)
+          @_memoized_collection_classes_mutex.synchronize do
+            _memoized_collection_classes[member_class][collection_type] = klass
+          end
+        end
+      end
+
+    included do
+      # Creates a new type that is a collection of this member types
+      # By default, T[] is equivalent to Collection.of(T)
+      # But you can pass the collection class to use, e.g. T[CSV] is equivalent to CSV.of(T)
+      def self.[](collection_type=Attributor::Collection)
+        member_class = self
+        existing = Attributor::Type.get_memoized_collection_class(member_class,collection_type)
+        return existing if existing
+
+        unless self.ancestors.include?(Attributor::Type)
+          raise Attributor::AttributorException, 'Collections can only have members that are Attributor::Types'
+        end
+
+        # Create and memoize it for non-constructable types here (like we do in Type[])
+        new_class = ::Class.new(collection_type) do
+          @member_type = member_class
+        end
+        if self.constructable?
+          new_class
+        else
+          # Unfortunately we cannot freeze the memoized class as it lazily sets the member_attribute inside
+          Attributor::Type.set_memoized_collection_class(new_class, member_class, collection_type)
+        end
+      end
+    end
     module ClassMethods
       # Does this type support the generation of subtypes?
       def constructable?
@@ -149,7 +204,9 @@ module Attributor
           option_value  # By default, describing an option returns the hash with the specification
         end
       end
-
+      def options
+        {}
+      end
     end
   end
 end

data/lib/attributor/types/bigdecimal.rb

@@ -16,6 +16,7 @@ module Attributor
       return nil if value.nil?
       return value if value.is_a?(native_type)
       return BigDecimal(value, 10) if value.is_a?(::Float)
+      return BigDecimal(value + '0') if value.is_a?(::String) && value.end_with?('.')
       BigDecimal(value)
     end
 

data/lib/attributor/types/collection.rb

@@ -12,13 +12,9 @@ module Attributor
     # @example Collection.of(Integer)
     #
     def self.of(type)
+      # Favor T[] since that even caches the non-construcable types
       resolved_type = Attributor.resolve_type(type)
-      unless resolved_type.ancestors.include?(Attributor::Type)
-        raise Attributor::AttributorException, 'Collections can only have members that are Attributor::Types'
-      end
-      ::Class.new(self) do
-        @member_type = resolved_type
-      end
+      resolved_type[self]
     end
 
     @options = {}

data/lib/attributor/types/float.rb

@@ -18,6 +18,7 @@ module Attributor
     end
 
     def self.load(value, context = Attributor::DEFAULT_ROOT_CONTEXT, **options)
+      return BigDecimal(value + '0') if value.is_a?(::String) && value.end_with?('.')
       Float(value)
     rescue TypeError
       super

data/lib/attributor/types/struct.rb

@@ -7,11 +7,19 @@ module Attributor
 
     # Construct a new subclass, using attribute_definition to define attributes.
     def self.construct(attribute_definition, options = {})
-      # if we're in a subclass of Struct, but not attribute_definition is provided, we're
+      # if we're in a subclass of Struct, but no attribute_definition is provided, we're
       # not REALLY trying to define a new struct. more than likely Collection is calling
       # construct on us.
       unless self == Attributor::Struct || attribute_definition.nil?
-        raise AttributorException, 'can not construct from already-constructed Struct'
+        location_file, location_line = attribute_definition.source_location
+        message = "You cannot change an already defined Struct type:\n"
+        message += "It seems you are trying to define attributes, using a block, on top of an existing concrete Struct type that already has been fully defined.\n"
+        message += "The place where you are trying to define the type is here:\n#{location_file} line #{location_line}\n#{attribute_definition.source}\n"
+        message += "If what you meant was to define a brand new Struct or Struct[], please make sure you pass the type in the attribute definition,\n"
+        message += "rather than leaving it blank.\n"
+        message += "Otherwise, what might be happening is that you have left out the explicit type, and the framework has inferred it from the"
+        message += "corresponding :reference type attribute (and hence running into the conflict of trying to redefine an existing type)."
+        raise AttributorException, message
       end
 
       # TODO: massage the options here to pull out only the relevant ones

data/lib/attributor/version.rb

@@ -1,3 +1,3 @@
 module Attributor
-  VERSION = '6.5'.freeze
+  VERSION = '7.0'.freeze
 end

data/spec/attribute_spec.rb

@@ -323,7 +323,7 @@ describe Attributor::Attribute do
     end
 
     context 'with a regexp' do
-      let(:example) { /\w+/ }
+      let(:example) { Regexp.new(/\w+/) }
       let(:generated_example) { /\w+/.gen }
 
       it 'calls #gen on the regexp' do
@@ -334,7 +334,7 @@ describe Attributor::Attribute do
 
       context 'for a type with a non-String native_type' do
         let(:type) { Attributor::Integer }
-        let(:example) { /\d{5}/ }
+        let(:example) { Regexp.new(/\d{5}/) }
         let(:generated_example) { /\d{5}/.gen }
 
         it 'coerces the example value properly' do

data/spec/dsl_compiler_spec.rb

@@ -25,7 +25,7 @@ describe Attributor::DSLCompiler do
         it 'raises an error for a missing type' do
           expect do
             dsl_compiler.attribute(attribute_name)
-          end.to raise_error(/type for attribute/)
+          end.to raise_error(/Type for attribute with name: name could not be determined/)
         end
 
         it 'creates an attribute given a name and type' do
@@ -38,7 +38,6 @@ describe Attributor::DSLCompiler do
           dsl_compiler.attribute(attribute_name, type, **attribute_options)
         end
       end
-
       context 'with a reference' do
         let(:dsl_compiler_options) { { reference: Turducken } }
 
@@ -66,16 +65,6 @@ describe Attributor::DSLCompiler do
           it 'accepts explicit nil type' do
             dsl_compiler.attribute(attribute_name, nil, **attribute_options)
           end
-
-          context 'but with the attribute also specifying a reference' do
-            let(:attribute_options) { { reference: Attributor::CSV } }
-            let(:expected_type) { Attributor::CSV }
-            let(:expected_options) { attribute_options }
-            it 'attribute reference takes precedence over the compiler one (and merges no options)' do
-              expect(attribute_options[:reference]).to_not eq(dsl_compiler_options[:reference])
-              dsl_compiler.attribute(attribute_name, **attribute_options)
-            end
-          end
         end
 
         context 'for a referenced Model attribute' do
@@ -104,23 +93,305 @@ describe Attributor::DSLCompiler do
         end
       end
 
-      context 'with a reference' do
+      context 'with a reference that contains the same name attribute' do
+        before { expect(dsl_compiler_options[:reference].attributes).to have_key(attribute_name) }
         let(:dsl_compiler_options) { { reference: Turducken } }
         let(:expected_options) do
           attribute_options.merge(reference: reference_type)
         end
 
-        it 'sets the type of the attribute to Struct' do
+        it 'defaults still to Struct (or Struct[] if reference type is a collection)' do
           expect(Attributor::Attribute).to receive(:new)
-            .with(expected_type, description: 'The turkey', reference: Turkey)
+            .with(expected_type, expected_options)
           dsl_compiler.attribute(attribute_name, **attribute_options, &attribute_block)
         end
+      end
 
-        it 'passes the correct reference to the created attribute' do
+      context 'with a reference that does NOT contains the same name attribute' do
+        before { expect(dsl_compiler_options[:reference].attributes).to_not have_key(attribute_name) }
+        let(:dsl_compiler_options) { { reference: Person } }
+        let(:expected_options) { attribute_options }
+        
+        it 'sets the type of the attribute to Struct (and doe NOT the options from the named ref attribute)' do
+          expect(Attributor::Attribute).to receive(:new)
+            .with(expected_type, expected_options)
+          dsl_compiler.attribute(attribute_name, **attribute_options, &attribute_block)
+        end
+
+        it 'same as above, picks Struct and just brings in the attr options' do
           expect(Attributor::Attribute).to receive(:new).with(expected_type, expected_options)
           dsl_compiler.attribute(attribute_name, type, **attribute_options, &attribute_block)
         end
       end
     end
   end
+
+  context 'type resolution, option inheritance for attributes with and without references' do
+    # Overall strategy
+    # 1) When no type is specified:
+    #   1.1) if it is a leaf (no block)
+    #     1.1.1) with an reference with an attr with the same name
+    #          - type copied from reference
+    #          - reference options are inherited as well (and can be overridden by local attribute ones)
+    #     1.1.2) without a ref (or the ref does not have same attribute name)
+    #          - Fail. Cannot determine type
+    #   1.2) if it has a block
+    #     1.2.1) with an reference with an attr with the same name
+    #          - Assume you want to define your new Struct (or Struct[]), yet pass ONLY the reference to the matching attribute
+    #            as you might want to refine the reference attributes (or not, but if you want, you can do it more tersely)
+    #           - the picked type will be Struct[] (if the reference attribute is a collection), or Struct otherwise
+    #     1.2.2) without a ref (or the ref does not have same attribute name)
+    #          - defaulted to Struct (if you meant Collection.of(Struct) things would fail later somehow)
+    #          - options are NOT inherited at all (This is something we should ponder more about)
+    # 2) When type is specified:
+    #   2.1) if it is a leaf (no block)
+    #     - ignore ref if there is one (with or without matching attribute name).
+    #     - simply use provided type, and provided options (no inheritance)
+    #   2.2) if it has a block
+    #     - Same as above: use type and options provided, ignore ref if there is one (with or without matching attribute name).
+
+    let(:mytype) do 
+      Class.new(Attributor::Struct, &myblock)
+    end
+    context 'with no explicit type specified' do
+      context 'without a block (if it is a leaf)' do
+        context 'that has a reference with an attribute with the same name' do
+          let(:myblock) { 
+            Proc.new do
+              attributes reference: Duck do
+                attribute :age, required: true, min: 42
+              end
+            end
+          }
+          it 'uses type from reference' do
+            expect(mytype.attributes).to have_key(:age)
+            expect(mytype.attributes[:age].type).to eq(Duck.attributes[:age].type)
+          end
+          it 'copies over reference options and allows the attribute to override/add some' do
+            merged_options = Duck.attributes[:age].options.merge(required: true, min: 42)
+            expect(mytype.attributes[:age].options).to include(merged_options)
+          end
+        end
+        context 'with a reference, but that does not have a matching attribute name' do
+          let(:myblock) { 
+            Proc.new do
+              attributes reference: Cormorant do
+                attribute :age
+              end
+            end
+          }
+          it 'fails resolving' do
+            expect{mytype.attributes}.to raise_error(/Type for attribute with name: age could not be determined./)
+          end
+        end
+        context 'without a reference' do
+          let(:myblock) { 
+            Proc.new do
+              attributes do
+                attribute :age
+              end
+            end
+          }
+          it 'fails resolving' do
+            expect{mytype.attributes}.to raise_error(/Type for attribute with name: age could not be determined./)
+          end
+        end
+      end
+      context 'with block (if it is NOT a leaf)' do
+        context 'that has a reference with an attribute with the same name' do
+
+          context 'which is not a Collection' do
+            let(:myblock) { 
+              Proc.new do
+                attributes reference: Duck do
+                  attribute :age, description: 'I am redefining'do
+                    attribute :foobar, Integer, min: 42
+                  end
+                end
+              end
+            }
+            it 'defaults to Struct' do
+              expect(mytype.attributes).to have_key(:age)
+              age_attribute = mytype.attributes[:age]
+              # Resolves to Struct
+              expect(age_attribute.type).to be < Attributor::Struct
+              # does NOT brings any ref options 
+              expect(age_attribute.options).to include(description: 'I am redefining')
+              expect(age_attribute.options).to include(reference: Duck.attributes[:age].type)
+              # And the nested attribute is correctly resolved as well, and ensures options are there
+              expect(age_attribute.type.attributes[:foobar].type).to eq(Attributor::Integer)
+              expect(age_attribute.type.attributes[:foobar].options).to eq(min: 42)
+            end
+          end
+          context 'which is a Collection' do
+            let(:myblock) { 
+              Proc.new do
+                attributes reference: Cormorant do
+                  # Babies is defined as a collection of structs
+                  attribute :babies, description: 'I am redefining babies'do
+                    attribute :name
+                    attribute :height, Integer, max: 33
+                  end
+                end
+              end
+            }
+            it 'defaults to Struct[]' do
+              expect(mytype.attributes).to have_key(:babies)
+              babies_attribute = mytype.attributes[:babies]
+              # Resolves to Struct[]
+              expect(babies_attribute.type).to be < Attributor::Collection
+              expect(babies_attribute.type.member_type).to be < Attributor::Struct
+              # does NOT brings any ref options 
+              expect(babies_attribute.options).to include(description: 'I am redefining babies')
+              expect(babies_attribute.options).to include(reference: Cormorant.attributes[:babies].type.member_type)
+
+              babies_member_attribute = babies_attribute.type.member_attribute
+              # And the nested attribute is correctly resolved as well, and ensures options are there
+              expect(babies_member_attribute.type.attributes[:name].type).to eq(Cormorant.attributes[:babies].type.member_type.attributes[:name].type)
+              expect(babies_member_attribute.type.attributes[:name].options).to eq(Cormorant.attributes[:babies].type.member_type.attributes[:name].options)
+              # Can add new attributes
+              expect(babies_member_attribute.type.attributes[:height].type).to eq(Attributor::Integer)
+              expect(babies_member_attribute.type.attributes[:height].options).to eq(max: 33)
+            end
+          end
+
+          context 'explicitly passing Collections' do
+            context 'using the full collection as reference' do
+              let(:myblock) { 
+                Proc.new do
+                  attributes do
+                    # Babies is defined as a collection of structs
+                    attribute :babies, reference: Cormorant[], description: 'I am redefining babies' do
+                    
+                      attribute :name
+                      attribute :height, Integer, max: 33
+                    end
+                  end
+                end
+              }
+              it 'complains, as reference must not be a collection' do
+                expect{mytype.attributes}.to raise_error(/:reference option cannot be a collection/)
+              end
+            end
+
+            context 'overriding the reference for a redefinition of a collection' do
+              let(:myblock) { 
+                Proc.new do
+                  attributes reference: Cormorant do
+                    # Babies is defined as a collection of structs, but we're passing a full (compatible) cormorant reference
+                    attribute :babies, reference: Cormorant, description: 'I am redefining babies'do
+                      attribute :name
+                      attribute :height, Integer, max: 33
+                    end
+                  end
+                end
+              }
+              it 'still unrolls it, defaults to Struct[] and properly resolves into the member type' do
+                expect(mytype.attributes).to have_key(:babies)
+                babies_attribute = mytype.attributes[:babies]
+                # Resolves to Struct[]
+                expect(babies_attribute.type).to be < Attributor::Collection
+                expect(babies_attribute.type.member_type).to be < Attributor::Struct
+                # does NOT brings any ref options 
+                expect(babies_attribute.options).to include(description: 'I am redefining babies')
+                expect(babies_attribute.options).to include(reference: Cormorant)
+              end
+            end
+          end
+        end
+        context 'with a reference, but that does not have a matching attribute name' do
+          let(:myblock) { 
+            Proc.new do
+              attributes reference: Cormorant do
+                attribute :age, description: 'I am redefining' do
+                  attribute :foobar, Integer, min: 42
+                end
+              end
+            end
+          }
+          it 'correctly defaults to Struct uses only the local options (same exact as if it had no reference)' do
+            expect(mytype.attributes).to have_key(:age)
+            age_attribute = mytype.attributes[:age]
+            # Resolves to Struct
+            expect(age_attribute.type).to be < Attributor::Struct
+            # does NOT brings any ref options 
+            expect(age_attribute.options).to  eq(description: 'I am redefining')
+            # And the nested attribute is correctly resolved as well, and ensures options are there
+            expect(age_attribute.type.attributes[:foobar].type).to eq(Attributor::Integer)
+            expect(age_attribute.type.attributes[:foobar].options).to eq(min: 42)
+          end
+        end
+        context 'without a reference' do
+          let(:myblock) { 
+            Proc.new do
+              attributes do
+                attribute :age, description: 'I am redefining' do
+                  attribute :foobar, Integer, min: 42
+                end
+              end
+            end
+          }
+          it 'correctly defaults to Struct uses only the local options' do
+            expect(mytype.attributes).to have_key(:age)
+            age_attribute = mytype.attributes[:age]
+            # Resolves to Struct
+            expect(age_attribute.type).to be < Attributor::Struct
+            # does NOT brings any ref options 
+            expect(age_attribute.options).to  eq(description: 'I am redefining')
+            # And the nested attribute is correctly resolved as well, and ensures options are there
+            expect(age_attribute.type.attributes[:foobar].type).to eq(Attributor::Integer)
+            expect(age_attribute.type.attributes[:foobar].options).to eq(min: 42)
+          end
+        end
+      end
+    end
+    context 'with an explicit type specified' do
+      context 'without a reference' do
+        let(:myblock) { 
+          Proc.new do
+            attributes do
+              attribute :age, String, description: 'I am a String now'
+            end
+          end
+        }
+        it 'always uses the provided type and local options specified' do
+          expect(mytype.attributes).to have_key(:age)
+          age_attribute = mytype.attributes[:age]
+          # Resolves to String
+          expect(age_attribute.type).to eq(Attributor::String)
+          # copies local options
+          expect(age_attribute.options).to  eq(description: 'I am a String now')
+        end
+      end
+      context 'with a reference' do
+        let(:myblock) { 
+          Proc.new do
+            attributes reference: Duck do
+              attribute :age, String, description: 'I am a String now'
+            end
+          end
+        }
+        it 'always uses the provided type and local options specified (same as if it had no reference)' do
+          expect(mytype.attributes).to have_key(:age)
+          age_attribute = mytype.attributes[:age]
+          # Resolves to String
+          expect(age_attribute.type).to eq(Attributor::String)
+          # copies local options
+          expect(age_attribute.options).to  eq(description: 'I am a String now')
+        end
+      end
+      context 'always uses the type and options specified ignoring any reference if there is one' do
+      end
+    end
+    context 'no reference no type for leaf' do
+      let(:myblock) { Proc.new do
+        attributes do
+          attribute :name
+        end
+      end }
+      it 'fails as it is not possible to resolve what type to use ' do
+        expect{mytype.attributes}.to raise_error(/Type for attribute with name: name could not be determined./)
+      end
+    end
+  end
 end

data/spec/support/models.rb

@@ -79,6 +79,11 @@ class Address < Attributor::Model
     attribute :name, String, example: /\w+/, null: true
     attribute :state, String, values: %w(OR CA), null: false
     attribute :person, Person, example: proc { |address, context| Person.example(context, address: address) }
+    attribute :substruct, reference: Address, null: false do
+      attribute :state, Struct do # redefine state as a Struct
+        attribute :foo, Integer, default: 1
+      end
+    end
     requires :name
   end
 end

data/spec/type_spec.rb

@@ -175,4 +175,35 @@ describe Attributor::Type do
       end
     end
   end
+
+  context 'collection sugar' do
+    context 'non-constructable types' do
+      [:BigDecimal, :Boolean, :Class, :DateTime, :Date, :Float, :Integer, 
+        :Object, :Regexp, :String,  :Symbol, :Tempfile, :Time, :URI]
+        .map{|sym| Attributor.const_get(sym)}
+        .each do |type|
+        before { expect(type.constructable?).to be(false) }
+        it "DSL is equivalent to Attributor::Collection.of(#{type})" do
+          collection = type[]
+          expect(collection).to be < Attributor::Collection
+          expect(collection.member_type).to be type
+        end
+        it "caches the collection type for #{type}" do
+          expect(type[]).to be(type[])
+        end
+      end
+    end
+    context 'constructable types' do
+      [:Hash, :Model, :Struct, :FileUpload]
+        .map{|sym| Attributor.const_get(sym)}
+        .each do |type|
+        before { expect(type.constructable?).to be(true) }
+        it "DSL is equivalent to Attributor::Collection.of(#{type})" do
+          collection = type[]
+          expect(collection).to be < Attributor::Collection
+          expect(collection.member_type).to be type
+        end
+      end
+    end
+  end
 end

data/spec/types/bigdecimal_spec.rb

@@ -42,6 +42,11 @@ describe Attributor::BigDecimal do
         expect(type.load('0')).to eq(0)
         expect(type.load('100')).to eq(100)
         expect(type.load('0.1')).to eq(0.1)
+        expect(type.load('.2')).to eq(0.2)
+        expect(type.load('-.2')).to eq(-0.2)
+        expect(type.load('10.')).to eq(10.0)
+        expect(type.load('-10.')).to eq(-10.0)
+        expect(type.load('-0.')).to eq(-0.0)
       end
     end
   end
@@ -49,7 +54,7 @@ describe Attributor::BigDecimal do
     subject(:js){ type.as_json_schema }
     it 'adds the right attributes' do
       expect(js.keys).to include(:type, :'x-type_name')
-      expect(js[:type]).to eq(:number)
+      expect(js[:type]).to eq(:string)
       expect(js[:'x-type_name']).to eq('BigDecimal')
     end
   end

data/spec/types/float_spec.rb

@@ -51,11 +51,19 @@ describe Attributor::Float do
 
     context 'for incoming String values' do
       context 'that are valid Floats' do
-        ['0.0', '-1.0', '1.0', '1e-10'].each do |value|
+        ['.2', '-.2', '0.0', '-1.0', '1.0', '1e-10'].each do |value|
           it 'decodes it if the String represents a Float' do
             expect(type.load(value)).to eq Float(value)
           end
         end
+        it 'decodes it if the String represents a Float and ends in .' do
+          expect(type.load('10.')).to eq Float('10.0')
+          expect(type.load('0.')).to eq Float('0.0')
+        end
+        it 'decodes it if the String represents a negative Float and ends in .' do
+          expect(type.load('-10.')).to eq Float('-10.0')
+          expect(type.load('-0.')).to eq Float('-0.0')
+        end
       end
 
       context 'that are valid Integers' do

data/spec/types/model_spec.rb

@@ -3,8 +3,6 @@ require File.join(File.dirname(__FILE__), '..', 'spec_helper.rb')
 describe Attributor::Model do
   subject(:chicken) { Chicken }
 
-  # TODO: should move most of these specs to hash spec
-
   context 'attributes' do
     context 'with an exception from the definition block' do
       subject(:broken_model) do
@@ -46,6 +44,31 @@ describe Attributor::Model do
         end.to raise_error(Attributor::InvalidDefinition)
       end
     end
+
+    context 'redefining an inheritable attribute name, with a different type' do
+      it 'is allowed' do      
+        aa = Address.attributes
+        # Substruct is a Struct with reference Address
+        expect(aa[:substruct].options).to include(:reference=>Address, null: false)
+        expect(aa[:substruct].type).to be <Attributor::Struct
+        expect(aa[:substruct].attributes.keys).to match([:state])
+        
+        state_attribute = aa[:substruct].attributes[:state]
+        # We expec the system to have percolated the inherited reference from Address.state ... but it won't be used
+        # as we're overriding it with a new Struct
+        expect(state_attribute.options).to include(:reference=>Attributor::String)
+        # We want to make sure no other options are set since we're starting a new structure from scratch (so it wouldn't
+        # major sense to inherit any other options? ) 
+        expect(state_attribute.options.keys).to_not include(:default, :values)
+        expect(state_attribute.type).to be < Attributor::Struct
+
+        # Foo gets its proper integer attribute as a leaf, and properly gets the default option as well
+        foo_attribute = state_attribute.attributes[:foo]
+        expect(foo_attribute.options).to include(default: 1)
+        expect(foo_attribute.attributes).to be_nil
+        expect(foo_attribute.type).to eq Attributor::Integer
+      end
+    end
   end
 
   context 'class methods' do
@@ -141,6 +164,18 @@ describe Attributor::Model do
         it { should have_key :age }
         it { should have_key :email }
       end
+
+      context 'other' do
+        subject(:attributes) { Address.attributes }
+        it 'works' do
+          expect(subject).to have_key(:substruct)
+          expect(subject[:substruct].type).to be < Attributor::Struct
+          expect(subject[:substruct].attributes).to have_key(:state)
+          expect(subject[:substruct].attributes[:state].type).to be < Attributor::Struct
+          expect(subject[:substruct].attributes[:state].attributes).to have_key(:foo)
+          expect(subject[:substruct].attributes[:state].attributes[:foo].type).to eq Attributor::Integer
+        end
+      end
     end
 
     context '.load' do
@@ -473,7 +508,7 @@ describe Attributor::Model do
     context 'for collections of models' do
       let(:attributes_block) do
         proc do
-          attribute :neighbors, required: true do
+          attribute :neighbors, Attributor::Collection.of(Attributor::Struct), required: true do
             attribute :name, required: true
             attribute :age, Integer
           end
@@ -482,8 +517,9 @@ describe Attributor::Model do
       subject(:struct) { Attributor::Struct.construct(attributes_block, reference: Cormorant) }
 
       it 'supports defining sub-attributes using the proper reference' do
+        # in construct, we're passing the reference, so it will use it to define the inner name/age attributes
         expect(struct.attributes[:neighbors].options[:required]).to be true
-        expect(struct.attributes[:neighbors].options[:null]).to be false
+        expect(struct.attributes[:neighbors].options).to_not have_key(:null) # Not inherited from reference
         expect(struct.attributes[:neighbors].type.member_attribute.type.attributes.keys).to match_array [:name, :age]
 
         name_options = struct.attributes[:neighbors].type.member_attribute.type.attributes[:name].options

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: attributor
 version: !ruby/object:Gem::Version
-  version: '6.5'
+  version: '7.0'
 platform: ruby
 authors:
 - Josep M. Blanquer
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-01-19 00:00:00.000000000 Z
+date: 2023-05-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: hashie
@@ -407,7 +407,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.2
+rubygems_version: 3.3.7
 signing_key:
 specification_version: 4
 summary: A powerful attribute and type management library for Ruby