attributor 5.1.0 → 5.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fe4a2dca77307723d8c18e4f37ded9cba8e54657
-  data.tar.gz: 175d9d21dd78aaba4e6c534559290cb79d3bf3a2
+  metadata.gz: f5472909b262b07126ca30d760aadb3f5bc0d362
+  data.tar.gz: 9e66f91088af8389b60d088dd4d7599acfd74d9a
 SHA512:
-  metadata.gz: 89de22ecae27da14b59f57b2ea87d3552c6d1dbdd338e07934bc29031fd4e65b664f4faf04fb50f56b2e3687cde7580ba217562a413856fa8cdb403c9bc4a335
-  data.tar.gz: d8beb7bba6e226b84d1608d080800e65ce632d3b9af0daeb6fa7415f0477d307d63ac9267b4ffd659fe846b9f1b0b3012d4853d8a1bb6a3d4bad4ff037aaa10b
+  metadata.gz: a7c963afb8460167b7714ae4dd4ae74f273ef703b11059e354f33f2356adfba3e9433dad3bc4497612beacfcaf67c727249a6e0143b5e45a0219b95e9c61ace0
+  data.tar.gz: ef1e2720295ee7456b08cd2c003e044f686958cb4e6ef3738f617d042c1ed2da0f1180e1cc5e11d0b97e0b74046eeead54f4a5b8f6bd843d4e092ab6662baa2b

data/CHANGELOG.md

@@ -2,6 +2,14 @@
 
 ## next
 
+## 5.2 (12/09/2017)
+
+* Fixed describing `Hash` with no keys defined, to still use a given example (no example outputted before this)
+* Fix bug that would occur when defining an attribute carrying a reference object, for which the reference type didn't have `attributes` (for example a Collection).
+* Allows an attribute to override the reference object through its options of its parent (even when its containing object already has one defined).
+* Built code to generate examples in a smarter way when complex conditional requirements are specified.
+
+
 ## 5.1
 
 * Added `Polymorphic` type. See [polymorphics.rb](spec/support/polymorphics.rb) for example usage.

data/attributor.gemspec

@@ -26,7 +26,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'rspec', '~> 3'
   spec.add_development_dependency 'rspec-its'
   spec.add_development_dependency 'rspec-collection_matchers', '~> 1'
-  spec.add_development_dependency('yard', ['~> 0.8.7'])
+  spec.add_development_dependency('yard')
   spec.add_development_dependency('backports', ['~> 3'])
   spec.add_development_dependency('yardstick', ['~> 0'])
   spec.add_development_dependency('bundler', ['>= 0'])

data/lib/attributor.rb

@@ -14,6 +14,7 @@ module Attributor
   require_relative 'attributor/dsl_compiler'
   require_relative 'attributor/hash_dsl_compiler'
   require_relative 'attributor/attribute_resolver'
+  require_relative 'attributor/smart_attribute_selector'
 
   require_relative 'attributor/example_mixin'
 

data/lib/attributor/dsl_compiler.rb

@@ -78,6 +78,8 @@ module Attributor
     #     end
     # @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
@@ -86,27 +88,33 @@ module Attributor
         end
       end
 
-      # determine inherited attribute
-      inherited_attribute = nil
-      if (reference = options[:reference])
-        if (inherited_attribute = reference.attributes[name])
+      # 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
-          opts[:reference] = inherited_attribute.type if block_given?
+          inherited_type = inherited_attribute.type
+          opts[:reference] = inherited_type if block_given?
         end
       end
 
       # determine attribute type to use
       if attr_type.nil?
         if block_given?
-          attr_type = if inherited_attribute && inherited_attribute.type < Attributor::Collection
+          # 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_attribute.type.member_attribute.type
+                        opts[:reference] = inherited_type.member_attribute.type
                         Attributor::Collection.of(Struct)
                       else
                         Attributor::Struct
                       end
-        elsif inherited_attribute
-          attr_type = inherited_attribute.type
+        elsif inherited_type
+          attr_type = inherited_type
         else
           raise AttributorException, "type for attribute with name: #{name} could not be determined"
         end

data/lib/attributor/exceptions.rb

@@ -34,4 +34,9 @@ module Attributor
       super msg
     end
   end
+
+  # Thrown from SmartAttributeSelector when the requirements of attributes are certainly unfeasible
+  class UnfeasibleRequirementsError < AttributorException
+  end
+
 end

data/lib/attributor/smart_attribute_selector.rb

@@ -0,0 +1,149 @@
+module Attributor
+  class SmartAttributeSelector
+    attr_accessor :reqs, :accepted, :banned, :remaining
+    attr_reader :reqs, :accepted, :banned, :remaining, :keys_with_values
+
+    def initialize( reqs , attributes, values)
+      @reqs = reqs.dup
+      @accepted = []
+      @banned = []
+      @remaining = attributes.dup
+      @keys_with_values = values.each_with_object([]){|(k,v),populated| populated.push(k) unless v == nil}
+    end
+
+    def process
+      process_required
+      process_exclusive
+      process_exactly
+      process_at_least
+      process_at_most
+      # Just add the ones that haven't been explicitly rejected
+      self.accepted += self.remaining
+      self.remaining = []
+      self.accepted.uniq!
+      self.accepted
+    end
+
+    def process_required
+      self.reqs = reqs.each_with_object([]) do |req, rest|
+        if req[:type] == :all
+          self.accepted += req[:attributes]
+          self.remaining -= req[:attributes]
+        else
+          rest.push req
+        end
+      end
+    end
+
+     def process_exclusive
+       self.reqs = reqs.each_with_object([]) do |req, rest|
+         if req[:type] == :exclusive ||
+           (req[:type] == :exactly && req[:count] == 1 ) ||
+           (req[:type] == :at_most && req[:count] == 1 )
+           process_exclusive_set(Array.new(req[:attributes]))
+         else
+           rest.push req
+         end
+       end
+     end
+
+     def process_at_least
+       self.reqs = reqs.each_with_object([]) do |req, rest|
+         if req[:type] == :at_least
+           process_at_least_set(Array.new(req[:attributes]), req[:count])
+         else
+           rest.push req
+         end
+       end
+     end
+
+     def process_at_most
+      self.reqs = reqs.each_with_object([]) do |req, rest|
+        if req[:type] == :at_most && req[:count] > 1 # count=1 is already handled in exclusive
+          process_at_most_set(Array.new(req[:attributes]), req[:count])
+        else
+          rest.push req
+        end
+      end
+     end
+
+     def process_exactly
+      self.reqs = reqs.each_with_object([]) do |req, rest|
+        if req[:type] == :exactly && req[:count] > 1 # count=1 is already handled in exclusive
+          process_exactly_set(Array.new(req[:attributes]), req[:count])
+        else
+          rest.push req
+        end
+      end
+     end
+
+     #################
+
+     def process_exclusive_set( exclusive_set )
+       feasible = exclusive_set - banned # available ones to pick (that are not banned)
+       # Try to favor attributes that come in with some values, otherwise get the first feasible one
+       preferred = feasible & keys_with_values
+       pick = (preferred.size == 0 ? feasible : preferred).first
+
+       if pick
+         self.accepted.push( pick )
+       else
+         raise UnfeasibleRequirementsError unless exclusive_set.empty?
+       end
+       self.banned += (feasible - [pick])
+       self.remaining -= exclusive_set
+     end
+
+     def process_at_least_set( at_least_set, count)
+       feasible = at_least_set - banned # available ones to pick (that are not banned)
+       preferred = (feasible & keys_with_values)[0,count]
+       # Add more if not enough
+       pick = if preferred.size < count
+         preferred + (feasible - preferred)[0,count-preferred.size]
+       else
+         preferred
+       end
+
+       unless pick.size == count
+         raise UnfeasibleRequirementsError
+       end
+       self.accepted += pick
+       self.remaining -= pick
+     end
+
+     def process_at_most_set( set, count)
+       ceil=(count+1)/2
+       feasible = set - banned # available ones to pick (that are not banned)
+       preferred = (feasible & keys_with_values)[0,ceil]
+
+       pick = if preferred.size < ceil
+         preferred + (feasible - preferred)[0,(ceil)-preferred.size]
+       else
+         preferred
+       end
+
+       self.accepted += pick
+       self.remaining -= pick
+     end
+
+     def process_exactly_set( set, count)
+       feasible = set - banned # available ones to pick (that are not banned)
+       preferred = (feasible & keys_with_values)[0,count]
+
+       pick = if preferred.size < count
+         preferred + (feasible - preferred)[0,count-preferred.size]
+       else
+         preferred
+       end
+
+       unless pick.size == count
+         raise UnfeasibleRequirementsError
+       end
+
+       self.accepted += pick
+       self.remaining -= pick
+     end
+
+
+  end
+end

data/lib/attributor/types/collection.rb

@@ -59,6 +59,7 @@ module Attributor
 
     # generates an example Collection
     # @return An Array of native type objects conforming to the specified member_type
+    # TODO:  ALLOW to pass  "values" for the members?...as values: {id: 1, ...}
     def self.example(context = nil, options: {})
       result = []
       size = options[:size] || (rand(3) + 1)

data/lib/attributor/types/hash.rb

@@ -16,7 +16,7 @@ module Attributor
   end
 
   class Hash
-    MAX_EXAMPLE_DEPTH = 5
+    MAX_EXAMPLE_DEPTH = 10
     CIRCULAR_REFERENCE_MARKER = '...'.freeze
 
     include Container
@@ -97,6 +97,13 @@ module Attributor
       @keys
     end
 
+    def self.requirements
+      if @saved_blocks.any?
+        definition
+      end
+      @requirements
+    end
+
     def self.definition
       opts = {
         key_type: @key_type,
@@ -168,11 +175,23 @@ module Attributor
       self
     end
 
+
+
     def self.example_contents(context, parent, **values)
       hash = ::Hash.new
       example_depth = context.size
-
-      keys.each do |sub_attribute_name, sub_attribute|
+      # Be smart about what attributes to use for the example: i.e. have into account complex requirements
+      # that might have been defined in the hash like at_most(1).of ..., exactly(2).of ...etc.
+      # But play it safe and default to the previous behavior in case there is any error processing them
+      # ( that is until the SmartAttributeSelector class isn't fully tested and ready for prime time)
+      begin
+        stack = SmartAttributeSelector.new( requirements.map(&:describe), keys.keys , values)
+        selected = stack.process
+      rescue => e
+        selected = keys.keys
+      end
+
+      keys.select{|n,attr| selected.include? n}.each do |sub_attribute_name, sub_attribute|
         if sub_attribute.attributes
           # TODO: add option to raise an exception in this case?
           next if example_depth > MAX_EXAMPLE_DEPTH
@@ -436,6 +455,7 @@ module Attributor
         end
       else
         hash[:value] = { type: value_type.describe(true) }
+        hash[:example] = example if example
       end
 
       hash

data/lib/attributor/version.rb

@@ -1,3 +1,3 @@
 module Attributor
-  VERSION = '5.1.0'.freeze
+  VERSION = '5.2.0'.freeze
 end

data/spec/dsl_compiler_spec.rb

@@ -66,6 +66,16 @@ 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

data/spec/smart_attribute_selector_spec.rb

@@ -0,0 +1,272 @@
+require File.join(File.dirname(__FILE__), 'spec_helper.rb')
+
+describe Attributor::SmartAttributeSelector do
+
+  let(:type) { Attributor::Hash.construct(block) }
+  let(:block) do
+    proc do
+      key :req1, String
+      key :req2, String
+      key :exc3, String
+      key :exc4, String
+      key :least1, String
+      key :least2, String
+      key :exact1, String
+      key :exact2, String
+      key :most1, String
+      key :most2, String
+
+      requires.all :req1, :req2
+      requires.exclusive :exc3, :exc4
+      requires.at_least(2).of :least1, :least2
+      requires.exactly(1).of :exc3, :exact1, :exact2
+      requires.at_most(1).of :most1, :most2
+      requires.at_least(1).of :exc4, :exc3
+    end
+  end
+
+  let(:reqs){ type.requirements.map(&:describe) }
+  let(:attributes){ [] }
+  let(:values){ {} }
+  let(:remaining_attrs){ [] }
+
+  subject(:selector){ Attributor::SmartAttributeSelector.new( reqs, attributes , values) }
+  let(:accepted_attrs){ [] }
+
+  after do
+    expect(subject.accepted).to contain_exactly(*accepted_attrs)
+    expect(subject.remaining).to contain_exactly(*remaining_attrs)
+  end
+
+  context 'process' do
+    let(:accepted_attrs){ [:req1, :req2, :exc3, :least1, :least2, :most1] }
+    it 'aggregates results from the different requirements' do
+      expect(subject).to receive(:process_required).once.and_call_original
+      expect(subject).to receive(:process_exclusive).once.and_call_original
+      expect(subject).to receive(:process_at_least).once.and_call_original
+      expect(subject).to receive(:process_exactly).once.and_call_original
+      expect(subject).to receive(:process_at_most).once.and_call_original
+      subject.process
+    end
+  end
+
+  context 'process_required' do
+    context 'processing only required attrs' do
+      let(:block) do
+        proc do
+          key :req1, String
+          key :req2, String
+          requires.all :req1, :req2
+        end
+      end
+      let(:accepted_attrs){ [:req1,:req2] }
+      it 'processes required' do
+        subject.process_required
+      end
+    end
+
+    context 'processing some required attrs, others attrs without reqs' do
+      let(:block) do
+        proc do
+          key :req1, String
+          key :req2, String
+          requires.all :req1
+        end
+      end
+      let(:accepted_attrs){ [:req1] }
+
+      it 'processes required' do
+        subject.process_required
+      end
+    end
+  end
+
+
+  context 'process_exclusive' do
+    context 'uses exclusive,at_most(1) and exactly(1)' do
+      let(:block) do
+        proc do
+          key :req1, String
+          key :req2, String
+          key :req3, String
+          key :req4, String
+          key :req5, String
+          key :req6, String
+
+          requires.exclusive :req1, :req2
+          requires.at_most(1).of :req3, :req4
+          requires.exactly(1).of :req5, :req6
+        end
+      end
+      let(:accepted_attrs){ [:req1,:req3,:req5] }
+      it 'processes required' do
+        expect(subject).to receive(:process_exclusive_set).with([:req1, :req2]).and_call_original
+        expect(subject).to receive(:process_exclusive_set).with([:req3, :req4]).and_call_original
+        expect(subject).to receive(:process_exclusive_set).with([:req5, :req6]).and_call_original
+
+        subject.process_exclusive
+      end
+    end
+  end
+
+
+
+  context 'internal functions' do
+
+    context 'process_exclusive_set' do
+      context 'picks the first of the set bans the rest' do
+        let(:set){ [:req1, :req2] }
+        let(:accepted_attrs){ [:req1] }
+
+        it 'processes required' do
+          subject.process_exclusive_set( set )
+          expect(subject.banned).to eq([:req2])
+        end
+      end
+
+      context 'picks the first not banned, and bans the rest' do
+        let(:set){ [:req2, :req3] }
+        let(:accepted_attrs){ [:req3] }
+
+        it 'processes required' do
+          subject.banned = [:req2] # Explicitly ban one
+          subject.process_exclusive_set( set )
+          expect(subject.banned).to eq([:req2])
+        end
+      end
+
+      context 'finds it unfeasible' do
+        let(:set){ [:req2, :req3] }
+
+        it 'processes required' do
+          subject.banned = [:req2, :req3] # Ban them all
+          expect{
+            subject.process_exclusive_set( set )
+          }.to raise_error(Attributor::UnfeasibleRequirementsError)
+        end
+        it 'unless the set was empty to begin with' do
+          expect{
+            subject.process_exclusive_set( [] )
+          }.to_not raise_error
+        end
+      end
+
+      context 'favors attributes with values' do
+        let(:values){ {req2: 'foo'} }
+        let(:set){ [:req1, :req2] }
+        let(:accepted_attrs){ [:req2] }
+
+        it 'processes required' do
+          subject.process_exclusive_set( set )
+          expect(subject.banned).to eq([:req1])
+        end
+      end
+
+      context 'manages the remaining set' do
+        let(:attributes){ [:req1, :req2, :req3] }
+        let(:set){ [:req1, :req2] }
+        let(:accepted_attrs){ [:req1] }
+        let(:remaining_attrs){ [:req3] }
+
+        it 'processes required' do
+          subject.process_exclusive_set( set )
+          expect(subject.banned).to eq([:req2])
+        end
+      end
+    end
+
+    context 'process_at_least_set' do
+      context 'picks the count in order' do
+        let(:set){ [:req1, :req2, :req3] }
+        let(:accepted_attrs){ [:req1,:req2] }
+
+        it 'processes required' do
+          subject.process_at_least_set( set,2 )
+        end
+      end
+
+      context 'picks the count in order, skipping banned' do
+        let(:set){ [:req1, :req2, :req3] }
+        let(:accepted_attrs){ [:req1,:req3] }
+
+        it 'processes required' do
+          subject.banned = [:req2] # Explicitly ban one
+          subject.process_at_least_set( set,2 )
+        end
+      end
+
+      context 'finds it unfeasible' do
+        let(:set){ [:req1, :req2, :req3] }
+
+        it 'processes required' do
+          expect{
+          subject.process_at_least_set( set,4 )
+          }.to raise_error(Attributor::UnfeasibleRequirementsError)
+        end
+      end
+
+      context 'favors attributes with values' do
+        let(:values){ {req1: 'foo', req3: 'bar'} }
+        let(:set){ [:req1, :req2, :req3] }
+        let(:accepted_attrs){ [:req1,:req3] }
+
+        it 'processes required' do
+          subject.process_at_least_set( set,2 )
+        end
+      end
+    end
+
+    context 'process_at_most_set' do
+      context 'picks half the max count in attr order' do
+        let(:set){ [:req1, :req2, :req3, :req4, :req5] }
+        let(:accepted_attrs){ [:req1,:req2] }
+
+        it 'processes required' do
+          subject.process_at_most_set( set,4 )
+        end
+      end
+      context 'favors attributes with values (and refills with others)' do
+        let(:values){ {req3: 'foo', req5: 'bar'} }
+        let(:set){ [:req1, :req2, :req3, :req4, :req5] }
+        let(:accepted_attrs){ [:req3,:req5,:req1] }
+
+        it 'processes required' do
+          subject.process_at_most_set( set,5 )
+        end
+      end
+    end
+
+    context 'process_exactly_set' do
+      context 'picks exact count in attr order' do
+        let(:set){ [:req1, :req2, :req3, :req4, :req5] }
+        let(:accepted_attrs){ [:req1,:req2] }
+
+        it 'processes required' do
+          subject.process_exactly_set( set, 2 )
+        end
+      end
+      context 'favors attributes with values (and refills with others)' do
+        let(:values){ {req3: 'foo'} }
+        let(:set){ [:req1, :req2, :req3, :req4, :req5] }
+        let(:accepted_attrs){ [:req3,:req1] }
+
+        it 'processes required' do
+          subject.process_exactly_set( set, 2 )
+        end
+      end
+
+      context 'finds it unfeasible' do
+        let(:set){ [:req1, :req2] }
+
+        it 'processes required' do
+          subject.banned = [:req2] # Explicitly ban one
+          expect{
+          subject.process_exactly_set( set, 2 )
+          }.to raise_error(Attributor::UnfeasibleRequirementsError)
+        end
+      end
+
+    end
+
+  end
+end

data/spec/types/hash_spec.rb

@@ -497,6 +497,22 @@ describe Attributor::Hash do
     end
   end
 
+  context '.requirements' do
+    let(:type) { Attributor::Hash.construct(block) }
+
+    context 'forces processing of lazy key initialization' do
+      let(:block) do
+        proc do
+          key 'name', String
+          requires 'name'
+        end
+      end
+
+      it 'lists the requirements' do
+        expect(type.requirements).to_not be_empty
+      end
+    end
+  end
   context '#validate' do
     context 'for a key and value typed hash' do
       let(:key_type) { Integer }
@@ -651,7 +667,7 @@ describe Attributor::Hash do
               at_least(1).of 'consistency', 'availability', 'partitioning'
             end
             # Silly example, just to show that block and inline requires can be combined
-            requires.at_most(3).of 'consistency', 'availability', 'partitioning'
+            requires.at_most(1).of 'consistency', 'availability', 'partitioning'
           end
         end
 
@@ -663,6 +679,37 @@ describe Attributor::Hash do
           )
         end
       end
+      context 'using a combo of things to test example gen' do
+        let(:block) do
+          proc do
+            key :req1, String
+            key :req2, String
+            key :exc3, String
+            key :exc4, String
+            key :least1, String
+            key :least2, String
+            key :exact1, String
+            key :exact2, String
+            key :most1, String
+            key :most2, String
+
+            requires.all :req1, :req2
+            requires.exclusive :exc3, :exc4
+            requires.at_least(2).of :least1, :least2
+            requires.exactly(1).of :exc3, :exact1, :exact2
+            requires.at_most(1).of :most1, :most2
+            requires.at_least(1).of :exc4, :exc3
+          end
+        end
+        it 'comes up with a reasonably good set' do
+          ex = type.example
+          expect(ex.keys).to match([:req1, :req2, :exc3, :least1, :least2, :most1])
+        end
+        it 'it favors picking attributes with data' do
+          ex = type.example(nil,{most2: "data"})
+          expect(ex.keys).to match([:req1, :req2, :exc3, :least1, :least2, :most2])
+        end
+      end
     end
   end
 
@@ -687,6 +734,13 @@ describe Attributor::Hash do
         expect(description[:name]).to eq('Hash')
         expect(description[:key]).to eq(type: { name: 'Object', id: 'Attributor-Object', family: 'any' })
         expect(description[:value]).to eq(type: { name: 'Object', id: 'Attributor-Object', family: 'any' })
+        expect(description).to_not have_key(:example)
+      end
+      context 'when there is a given example' do
+        let(:example) { { 'one' => 1, two: 2 } }
+        it 'uses it, even though there are not individual keys' do
+          expect(description[:example]).to eq(example)
+        end
       end
     end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: attributor
 version: !ruby/object:Gem::Version
-  version: 5.1.0
+  version: 5.2.0
 platform: ruby
 authors:
 - Josep M. Blanquer
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-08-18 00:00:00.000000000 Z
+date: 2017-12-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: hashie
@@ -99,16 +99,16 @@ dependencies:
   name: yard
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 0.8.7
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 0.8.7
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: backports
   requirement: !ruby/object:Gem::Requirement
@@ -338,6 +338,7 @@ files:
 - lib/attributor/families/numeric.rb
 - lib/attributor/families/temporal.rb
 - lib/attributor/hash_dsl_compiler.rb
+- lib/attributor/smart_attribute_selector.rb
 - lib/attributor/type.rb
 - lib/attributor/types/bigdecimal.rb
 - lib/attributor/types/boolean.rb
@@ -371,6 +372,7 @@ files:
 - spec/extras/field_selector/field_selector_spec.rb
 - spec/families_spec.rb
 - spec/hash_dsl_compiler_spec.rb
+- spec/smart_attribute_selector_spec.rb
 - spec/spec_helper.rb
 - spec/support/hashes.rb
 - spec/support/models.rb
@@ -419,7 +421,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 2.6.12
 signing_key: 
 specification_version: 4
 summary: A powerful attribute and type management library for Ruby
@@ -432,6 +434,7 @@ test_files:
 - spec/extras/field_selector/field_selector_spec.rb
 - spec/families_spec.rb
 - spec/hash_dsl_compiler_spec.rb
+- spec/smart_attribute_selector_spec.rb
 - spec/spec_helper.rb
 - spec/support/hashes.rb
 - spec/support/models.rb
@@ -460,4 +463,3 @@ test_files:
 - spec/types/time_spec.rb
 - spec/types/type_spec.rb
 - spec/types/uri_spec.rb
-has_rdoc: