attributor 5.5 → 6.1

data/spec/attribute_spec.rb

@@ -11,7 +11,7 @@ describe Attributor::Attribute do
 
   context 'initialize' do
     its(:type) { should be type }
-    its(:options) { should be attribute_options }
+    its(:options) { should eq attribute_options }
 
     it 'calls check_options!' do
       expect_any_instance_of(Attributor::Attribute).to receive(:check_options!)
@@ -62,6 +62,7 @@ describe Attributor::Attribute do
       it 'as well as the type-specific ones' do
         expect(js[:type]).to eq(:integer)
       end
+
     end
 
   end
@@ -71,8 +72,8 @@ describe Attributor::Attribute do
     let(:expected) do
       h = {type: {name: 'String', id: type.id, family: type.family}}
       common = attribute_options.select{|k,v| Attributor::Attribute::TOP_LEVEL_OPTIONS.include? k }
-      h.merge!( common )
-      h[:options] = {:min => 0 }
+      h.merge!(common)
+      h[:options] = {min: 0}
       h
     end
 
@@ -194,6 +195,49 @@ describe Attributor::Attribute do
         end.not_to raise_error
       end
     end
+
+    context 'custom_options' do
+      let(:option_name) { :foo }
+      let(:custom_option_args) { [option_name, String] }
+
+      around do |example|
+        Attributor::Attribute.custom_option *custom_option_args
+        example.run
+        Attributor::Attribute.custom_options.delete option_name
+      end
+
+      it 'raises ArgumentError if given an existing option' do
+        expect {
+          Attributor::Attribute.custom_option :default, Object
+        }.to raise_error(ArgumentError)
+      end
+
+      it 'accepts custom options' do
+        expect do
+          Attributor::Attribute.new(Integer, foo: 'unvalidated')
+        end.not_to raise_error
+      end
+
+      context 'can validate the custom option value' do 
+        let(:custom_option_args) { [option_name, String, values: ['valid']] }
+        it 'does not raise with a valid option value' do
+          expect do
+            Attributor::Attribute.new(Integer, foo: 'valid')
+          end.not_to raise_error
+        end
+        it 'raises with an invalid option value' do
+          expect do
+            Attributor::Attribute.new(Integer, foo: 'invalid')
+          end.to raise_error(Attributor::AttributorException)
+        end
+      end
+
+      it 'appear in as_json_schema' do
+        attribute = Attributor::Attribute.new(Integer, foo: 'valid')
+        json_schema = attribute.as_json_schema
+        expect(json_schema[:'x-foo']).to eq 'valid'
+      end
+    end
   end
 
   context 'example' do
@@ -414,10 +458,49 @@ describe Attributor::Attribute do
         context 'applying attribute options' do
           context ':required' do
             let(:attribute_options) { { required: true } }
+            context 'has no effect on a bare attribute' do
+              let(:value) { 'val' }
+              it 'it does not error, as we do not know if the parent attribute key was passed in (done at the Hash level)' do
+                expect(attribute.validate(value, context)).to be_empty
+              end
+            end
+          end
+          context ':null false (non-nullable)' do
+            let(:attribute_options) { { null: false } }
+            context 'with a nil value' do
+              let(:value) { nil }
+              it 'returns an error' do
+                expect(attribute.validate(value, context).first).to eq 'Attribute context is not nullable'
+              end
+            end
+          end
+          context ':null true (nullable)' do
+            let(:attribute_options) { { null: true } }
+            context 'with a nil value' do
+              let(:value) { nil }
+              it 'does not error' do
+                expect(attribute.validate(value, context)).to be_empty
+              end
+            end
+          end
+          context 'defaults to non-nullable if null not defined' do
+            let(:attribute_options) { { } }
             context 'with a nil value' do
               let(:value) { nil }
               it 'returns an error' do
-                expect(attribute.validate(value, context).first).to eq 'Attribute context is required'
+                expect(Attributor::Attribute.default_for_null).to be(false)
+                expect(attribute.validate(value, context).first).to eq 'Attribute context is not nullable'
+              end
+            end
+          end
+
+          context 'default can be overrideable with true' do
+            let(:attribute_options) { { } }
+            context 'with a nil value' do
+              let(:value) { nil }
+              it 'suceeds' do
+                expect(Attributor::Attribute).to receive(:default_for_null).and_return(true)
+                expect(attribute.validate(value, context)).to be_empty
               end
             end
           end
@@ -463,6 +546,13 @@ describe Attributor::Attribute do
           end
         end
 
+        context 'with a nil value' do
+          let(:value) { nil }
+          it 'returns no errors' do
+            expect(errors).to be_empty
+          end
+        end
+
         context 'with a value of a value different than the native_type' do
           let(:value) { 1 }
 
@@ -472,58 +562,6 @@ describe Attributor::Attribute do
           end
         end
       end
-
-      context '#validate_missing_value' do
-        let(:key) { '$.instance.ssh_key.name' }
-        let(:value) { /\w+/.gen }
-
-        let(:attribute_options) { { required_if: key } }
-
-        let(:ssh_key) { double('ssh_key', name: value) }
-        let(:instance) { double('instance', ssh_key: ssh_key) }
-
-        before { Attributor::AttributeResolver.current.register('instance', instance) }
-
-        let(:attribute_context) { ['$', 'params', 'key_material'] }
-        subject(:errors) { attribute.validate_missing_value(attribute_context) }
-
-        context 'for a simple dependency without a predicate' do
-          context 'that is satisfied' do
-            it { should_not be_empty }
-          end
-
-          context 'that is missing' do
-            let(:value) { nil }
-            it { should be_empty }
-          end
-        end
-
-        context 'with a dependency that has a predicate' do
-          let(:value) { 'default_ssh_key_name' }
-          # subject(:errors) { attribute.validate_missing_value('') }
-
-          context 'where the target attribute exists, and matches the predicate' do
-            let(:attribute_options) { { required_if: { key => /default/ } } }
-
-            it { should_not be_empty }
-
-            its(:first) { should match(/Attribute #{Regexp.quote(Attributor.humanize_context(attribute_context))} is required when #{Regexp.quote(key)} matches/) }
-          end
-
-          context 'where the target attribute exists, but does not match the predicate' do
-            let(:attribute_options) { { required_if: { key => /other/ } } }
-
-            it { should be_empty }
-          end
-
-          context 'where the target attribute does not exist' do
-            let(:attribute_options) { { required_if: { key => /default/ } } }
-            let(:ssh_key) { double('ssh_key', name: nil) }
-
-            it { should be_empty }
-          end
-        end
-      end
     end
 
     context 'for an attribute for a subclass of Model' do
@@ -592,71 +630,6 @@ describe Attributor::Attribute do
           end
         end
       end
-
-      context '#validate_missing_value' do
-        let(:type) { Duck }
-        let(:attribute_name) { nil }
-        let(:attribute) { Duck.attributes[attribute_name] }
-
-        let(:attribute_context) { ['$', 'duck', attribute_name.to_s] }
-        subject(:errors) { attribute.validate_missing_value(attribute_context) }
-
-        before do
-          Attributor::AttributeResolver.current.register('duck', duck)
-        end
-
-        context 'for a dependency with no predicate' do
-          let(:attribute_name) { :email }
-
-          let(:duck) do
-            d = Duck.new
-            d.age = 1
-            d.name = 'Donald'
-            d
-          end
-
-          context 'where the target attribute exists, and matches the predicate' do
-            it { should_not be_empty }
-            its(:first) { should eq 'Attribute $.duck.email is required when name (for $.duck) is present.' }
-          end
-          context 'where the target attribute does not exist' do
-            before do
-              duck.name = nil
-            end
-            it { should be_empty }
-          end
-        end
-
-        context 'for a dependency with a predicate' do
-          let(:attribute_name) { :age }
-
-          let(:duck) do
-            d = Duck.new
-            d.name = 'Daffy'
-            d.email = 'daffy@darkwing.uoregon.edu' # he's a duck,get it?
-            d
-          end
-
-          context 'where the target attribute exists, and matches the predicate' do
-            it { should_not be_empty }
-            its(:first) { should match(/Attribute #{Regexp.quote('$.duck.age')} is required when name #{Regexp.quote('(for $.duck)')} matches/) }
-          end
-
-          context 'where the target attribute exists, and does not match the predicate' do
-            before do
-              duck.name = 'Donald'
-            end
-            it { should be_empty }
-          end
-
-          context 'where the target attribute does not exist' do
-            before do
-              duck.name = nil
-            end
-            it { should be_empty }
-          end
-        end
-      end
     end
   end
 
@@ -713,4 +686,24 @@ describe Attributor::Attribute do
       end
     end
   end
+
+  context '.nullable_attribute?' do
+    subject { described_class.nullable_attribute?(options) }
+    context 'with null: true option' do
+      let(:options) { { null: true } }  
+      it { should be_truthy }
+    end
+    context 'with null: false option' do
+      let(:options) { { null: false } }  
+      it { should be_falsey }
+    end
+    context 'defaults to false without any null option' do
+      let(:options) { { } }  
+      it { should be_falsey }
+    end
+    context 'defaults to false if null: nil' do
+      let(:options) { { null: nil } }  
+      it { should be_falsey }
+    end
+  end
 end

data/spec/hash_dsl_compiler_spec.rb

@@ -109,31 +109,31 @@ describe Attributor::HashDSLCompiler do
       context 'for :all' do
         let(:arguments) { { all: [:one, :two, :three] } }
         let(:value) { [:one] }
-        let(:validation_error) { ['Key two is required for $.', 'Key three is required for $.'] }
+        let(:validation_error) { ["Attribute $.key(:two) is required.", "Attribute $.key(:three) is required."] }
         it { expect(subject).to include(*validation_error) }
       end
       context 'for :exactly' do
         let(:requirement) { req_class.new(exactly: 1).of(:one, :two) }
         let(:value) { [:one, :two] }
-        let(:validation_error) { 'Exactly 1 of the following keys [:one, :two] are required for $. Found 2 instead: [:one, :two]' }
+        let(:validation_error) { 'Exactly 1 of the following attributes [:one, :two] are required for $. Found 2 instead: [:one, :two]' }
         it { expect(subject).to include(validation_error) }
       end
       context 'for :at_least' do
         let(:requirement) { req_class.new(at_least: 2).of(:one, :two, :three) }
         let(:value) { [:one] }
-        let(:validation_error) { 'At least 2 keys out of [:one, :two, :three] are required to be passed in for $. Found [:one]' }
+        let(:validation_error) { 'At least 2 attributes out of [:one, :two, :three] are required to be passed in for $. Found [:one]' }
         it { expect(subject).to include(validation_error) }
       end
       context 'for :at_most' do
         let(:requirement) { req_class.new(at_most: 1).of(:one, :two, :three) }
         let(:value) { [:one, :two] }
-        let(:validation_error) { 'At most 1 keys out of [:one, :two, :three] can be passed in for $. Found [:one, :two]' }
+        let(:validation_error) { 'At most 1 attributes out of [:one, :two, :three] can be passed in for $. Found [:one, :two]' }
         it { expect(subject).to include(validation_error) }
       end
       context 'for :exclusive' do
         let(:arguments) { { exclusive: [:one, :two] } }
         let(:value) { [:one, :two] }
-        let(:validation_error) { 'keys [:one, :two] are mutually exclusive for $.' }
+        let(:validation_error) { 'Attributes [:one, :two] are mutually exclusive for $.' }
         it { expect(subject).to include(validation_error) }
       end
     end

data/spec/spec_helper.rb

@@ -23,9 +23,7 @@ Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each { |f| require f }
 
 RSpec.configure do |config|
   config.around(:each) do |example|
-    Attributor::AttributeResolver.current = Attributor::AttributeResolver.new
     example.run
-    Attributor::AttributeResolver.current = nil
   end
 end
 

data/spec/support/models.rb

@@ -11,9 +11,9 @@ end
 
 class Duck < Attributor::Model
   attributes do
-    attribute :age, Attributor::Integer, required_if: { 'name' => 'Daffy' }
+    attribute :age, Attributor::Integer
     attribute :name, Attributor::String
-    attribute :email, Attributor::String, required_if: 'name'
+    attribute :email, Attributor::String
     attribute :angry, Attributor::Boolean, default: true, example: /true|false/, description: 'Angry bird?'
     attribute :weight, Attributor::Float, example: /\d{1,2}\.\d/, description: 'The weight of the duck'
     attribute :type, Attributor::Symbol, values: [:duck]
@@ -50,15 +50,15 @@ class Cormorant < Attributor::Model
     end
 
     # This will be a collection of arbitrary Ruby Objects
-    attribute :fish, Attributor::Collection, description: 'All kinds of fish for feeding the babies'
+    attribute :all_the_fish, Attributor::Collection, description: 'All kinds of fish for feeding the babies'
 
     # This will be a collection of Cormorants (note, this relationship is circular)
-    attribute :neighbors, Attributor::Collection.of(Cormorant), description: 'Neighbor cormorants'
+    attribute :neighbors, Attributor::Collection.of(Cormorant), member_options: {null: false}, description: 'Neighbor cormorants', null: false
 
     # This will be a collection of instances of an anonymous Struct class, each having two well-defined attributes
 
     attribute :babies, Attributor::Collection.of(Attributor::Struct), description: 'All the babies', member_options: { identity: :name } do
-      attribute :name, Attributor::String, example: /[:name]/, description: 'The name of the baby cormorant'
+      attribute :name, Attributor::String, example: /[:name]/, description: 'The name of the baby cormorant', required: true
       attribute :months, Attributor::Integer, default: 0, min: 0, description: 'The age in months of the baby cormorant'
       attribute :weight, Attributor::Float, example: /\d{1,2}\.\d{3}/, description: 'The weight in kg of the baby cormorant'
     end
@@ -76,8 +76,8 @@ end
 
 class Address < Attributor::Model
   attributes do
-    attribute :name, String, example: /\w+/
-    attribute :state, String, values: %w(OR CA)
+    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) }
     requires :name
   end

data/spec/types/hash_spec.rb

@@ -514,6 +514,7 @@ describe Attributor::Hash do
       end
     end
   end
+
   context '#validate' do
     context 'for a key and value typed hash' do
       let(:key_type) { Integer }
@@ -534,45 +535,85 @@ describe Attributor::Hash do
     context 'for a hash with defined keys' do
       let(:block) do
         proc do
-          key 'integer', Integer
+          key 'integer', Integer, null: false # non-nullable, but not required
           key 'datetime', DateTime
-          key 'not-optional', String, required: true
+          key 'not-optional', String, required: true, null: false # required AND non-nullable
+          key 'required-but-nullable', String, required: true, null: true
         end
       end
 
       let(:type) { Attributor::Hash.construct(block) }
-
-      let(:values) { { 'integer' => 'one', 'datetime' => 'now' } }
       subject(:hash) { type.new(values) }
 
-      it 'validates the keys' do
-        errors = hash.validate
-        expect(errors).to have(3).items
-        expect(errors).to include('Attribute $.key("not-optional") is required')
+      context 'validates it all' do
+        let(:values) { { 'integer' => 'one', 'datetime' => 'now', 'required-but-nullable' => nil} }
+        it 'validates the keys' do
+          errors = hash.validate
+          expect(errors).to have(3).items
+          [
+            'Attribute $.key("integer") received value: "one" is of the wrong type (got: String, expected: Attributor::Integer)',
+            'Attribute $.key("datetime") received value: "now" is of the wrong type (got: String, expected: Attributor::DateTime)',
+            'Attribute $.key("not-optional") is required'
+          ].each do |msg|
+            regexp = Regexp.new(Regexp.escape(msg))
+            expect(errors.any?{|err| err =~ regexp}).to be_truthy
+          end
+        end
+      end
+      
+      context 'still validates requiredness even if values are nullable' do
+        let(:values) { {} }
+        it 'complains if not provided' do
+          errors = hash.validate
+          expect(errors).to have(2).items
+          [
+            'Attribute $.key("not-optional") is required',
+            'Attribute $.key("required-but-nullable") is required'
+          ].each do |msg|
+            regexp = Regexp.new(Regexp.escape(msg))
+            expect(errors.any?{|err| err =~ regexp}).to be_truthy
+          end
+        end
       end
+
+      context 'validates nullability regardless of requiredness' do
+        let(:values) { {'integer'  => nil, 'not-optional' => nil, 'required-but-nullable' => nil} }
+        it 'complains if null' do
+          errors = hash.validate
+          expect(errors).to have(2).items
+          [
+            'Attribute $.key("integer") is not nullable',
+            'Attribute $.key("not-optional") is not nullable',
+          ].each do |msg|
+            regexp = Regexp.new(Regexp.escape(msg))
+            expect(errors.any?{|err| err =~ regexp}).to be_truthy
+          end
+        end
+      end
+      
     end
 
     context 'with requirements defined' do
       let(:type) { Attributor::Hash.construct(block) }
 
-      context 'using requires' do
+      context 'using the requires DSL' do
         let(:block) do
           proc do
             key 'name', String
+            key 'nevernull', String, null: false
             key 'consistency', Attributor::Boolean
-            key 'availability', Attributor::Boolean
-            key 'partitioning', Attributor::Boolean
+            key 'availability', Attributor::Boolean, null: true
+            key 'partitioning', Attributor::Boolean, null: true
             requires 'consistency', 'availability'
-            requires.all 'name' # Just to show that it is equivalent to 'requires'
+            requires.all 'name'
           end
         end
 
         it 'complains not all the listed elements are set (false or true)' do
-          errors = type.new('name' => 'CAP').validate
+          errors = type.new('name' => 'CAP', 'consistency' => true, 'nevernull' => nil).validate
           expect(errors).to have(2).items
-          %w(consistency availability).each do |name|
-            expect(errors).to include("Key #{name} is required for $.")
-          end
+          expect(errors).to include('Attribute $.key("nevernull") is not nullable.')
+          expect(errors).to include('Attribute $.key("availability") is required.')
         end
       end
 
@@ -591,7 +632,7 @@ describe Attributor::Hash do
           errors = type.new('name' => 'CAP', 'consistency' => false).validate
           expect(errors).to have(1).items
           expect(errors).to include(
-            'At least 2 keys out of ["consistency", "availability", "partitioning"] are required to be passed in for $. Found ["consistency"]'
+            'At least 2 attributes out of ["consistency", "availability", "partitioning"] are required to be passed in for $. Found ["consistency"]'
           )
         end
       end
@@ -610,7 +651,7 @@ describe Attributor::Hash do
         it 'complains if more than 2 in the group are set (false or true)' do
           errors = type.new('name' => 'CAP', 'consistency' => false, 'availability' => true, 'partitioning' => false).validate
           expect(errors).to have(1).items
-          expect(errors).to include('At most 2 keys out of ["consistency", "availability", "partitioning"] can be passed in for $. Found ["consistency", "availability", "partitioning"]')
+          expect(errors).to include('At most 2 attributes out of ["consistency", "availability", "partitioning"] can be passed in for $. Found ["consistency", "availability", "partitioning"]')
         end
       end
 
@@ -628,12 +669,12 @@ describe Attributor::Hash do
         it 'complains if less than 1 in the group are set (false or true)' do
           errors = type.new('name' => 'CAP').validate
           expect(errors).to have(1).items
-          expect(errors).to include('Exactly 1 of the following keys ["consistency", "availability", "partitioning"] are required for $. Found 0 instead: []')
+          expect(errors).to include('Exactly 1 of the following attributes ["consistency", "availability", "partitioning"] are required for $. Found 0 instead: []')
         end
         it 'complains if more than 1 in the group are set (false or true)' do
           errors = type.new('name' => 'CAP', 'consistency' => false, 'availability' => true).validate
           expect(errors).to have(1).items
-          expect(errors).to include('Exactly 1 of the following keys ["consistency", "availability", "partitioning"] are required for $. Found 2 instead: ["consistency", "availability"]')
+          expect(errors).to include('Exactly 1 of the following attributes ["consistency", "availability", "partitioning"] are required for $. Found 2 instead: ["consistency", "availability"]')
         end
       end
 
@@ -651,7 +692,7 @@ describe Attributor::Hash do
         it 'complains if two or more in the group are set (false or true)' do
           errors = type.new('name' => 'CAP', 'consistency' => false, 'availability' => true).validate
           expect(errors).to have(1).items
-          expect(errors).to include('keys ["consistency", "availability"] are mutually exclusive for $.')
+          expect(errors).to include('Attributes ["consistency", "availability"] are mutually exclusive for $.')
         end
       end
 
@@ -676,7 +717,7 @@ describe Attributor::Hash do
           errors = type.new('name' => 'CAP').validate
           expect(errors).to have(1).items
           expect(errors).to include(
-            'At least 1 keys out of ["consistency", "availability", "partitioning"] are required to be passed in for $. Found none'
+            'At least 1 attributes out of ["consistency", "availability", "partitioning"] are required to be passed in for $. Found none'
           )
         end
       end

data/spec/types/model_spec.rb

@@ -371,7 +371,12 @@ describe Attributor::Model do
     context 'for models using the "requires" DSL' do
       subject(:address) { Address.load({state: 'CA'}) }
       its(:validate) { should_not be_empty }
-      its(:validate) { should include 'Key name is required for $.' }
+      its(:validate) { should include 'Attribute $.key(:name) is required.' }
+    end
+    context 'for models with non-nullable attributes' do
+      subject(:address) { Address.load({name: nil, state: nil}) }
+      its(:validate) { should_not be_empty }
+      its(:validate) { should include 'Attribute $.state is not nullable.' } # name is nullable
     end
     context 'for models with circular sub-attributes' do
       context 'that are valid' do
@@ -478,6 +483,7 @@ describe Attributor::Model do
 
       it 'supports defining sub-attributes using the proper reference' do
         expect(struct.attributes[:neighbors].options[:required]).to be true
+        expect(struct.attributes[:neighbors].options[:null]).to be false
         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: '5.5'
+  version: '6.1'
 platform: ruby
 authors:
 - Josep M. Blanquer
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-08-21 00:00:00.000000000 Z
+date: 2022-02-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: hashie
@@ -312,7 +312,6 @@ files:
 - attributor.gemspec
 - lib/attributor.rb
 - lib/attributor/attribute.rb
-- lib/attributor/attribute_resolver.rb
 - lib/attributor/dsl_compiler.rb
 - lib/attributor/dumpable.rb
 - lib/attributor/example_mixin.rb
@@ -350,7 +349,6 @@ files:
 - lib/attributor/types/time.rb
 - lib/attributor/types/uri.rb
 - lib/attributor/version.rb
-- spec/attribute_resolver_spec.rb
 - spec/attribute_spec.rb
 - spec/attributor_spec.rb
 - spec/dsl_compiler_spec.rb
@@ -407,13 +405,11 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.6.14
+rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
 summary: A powerful attribute and type management library for Ruby
 test_files:
-- spec/attribute_resolver_spec.rb
 - spec/attribute_spec.rb
 - spec/attributor_spec.rb
 - spec/dsl_compiler_spec.rb