attributor 5.4 → 6.0

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!)
@@ -36,17 +36,49 @@ describe Attributor::Attribute do
     it { should eq other_attribute }
   end
 
+  context 'describe_json_schema' do
+    let(:type) { PositiveIntegerType }
+
+    let(:attribute_options) do
+      {
+        values: [1,20],
+        description: "something",
+        example: 20,
+        max: 1000,
+        default: 1
+      }
+    end
+
+    context 'reports all of the possible attributes' do
+      let(:js){ subject.as_json_schema(example: 20) }
+
+      it 'including the attribute-specific ones' do
+        expect(js[:enum]).to eq( [1,20])
+        expect(js[:description]).to eq( "something")
+        expect(js[:default]).to eq(1)
+        expect(js[:example]).to eq(20)
+      end
+
+      it 'as well as the type-specific ones' do
+        expect(js[:type]).to eq(:integer)
+      end
+
+    end
+
+  end
+
   context 'describe' do
-    let(:attribute_options) { { required: true, values: ['one'], description: 'something', min: 0 } }
+    let(:attribute_options) { {required: true, values: ['one'], description: "something", min: 0} }
     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 = {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[:options] = {min: 0}
       h
     end
 
-    its(:describe) { should eq expected }
+    # It has both the type-included options (min) as well as the attribute options (max)
+    its(:describe) { should == expected }
 
     context 'with example options' do
       let(:attribute_options) { { description: 'something', example: 'ex_def' } }
@@ -163,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
@@ -383,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 required'
+                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(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
@@ -432,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 }
 
@@ -441,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
@@ -561,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
 
@@ -682,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/extras/field_selector/field_selector_spec.rb

@@ -33,4 +33,13 @@ describe Attributor::FieldSelector do
       end
     end
   end
+
+  context '.as_json_schema' 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(:string)
+      expect(js[:'x-type_name']).to eq('FieldSelector')
+    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/integers.rb

@@ -0,0 +1,7 @@
+class PositiveIntegerType < Attributor::Integer
+
+  def self.options
+    { min: 0 }
+  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/bigdecimal_spec.rb

@@ -45,4 +45,12 @@ describe Attributor::BigDecimal do
       end
     end
   end
+  context '.as_json_schema' 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[:'x-type_name']).to eq('BigDecimal')
+    end
+  end
 end

data/spec/types/boolean_spec.rb

@@ -7,6 +7,8 @@ describe Attributor::Boolean do
     expect(type.new.is_a?(Attributor::Dumpable)).not_to be(true)
   end
 
+  its(:json_schema_type){ should eq(:boolean)}
+
   context '.valid_type?' do
     context 'for incoming Boolean values' do
       [false, true].each do |value|
@@ -63,4 +65,12 @@ describe Attributor::Boolean do
       end
     end
   end
+  context '.as_json_schema' 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(:boolean)
+      expect(js[:'x-type_name']).to eq('Boolean')
+    end
+  end
 end

data/spec/types/collection_spec.rb

@@ -344,4 +344,20 @@ describe Attributor::Collection do
       end.to_not raise_error
     end
   end
+
+  context '.as_json_schema' do
+    let(:member_type) { Attributor::String }
+    let(:type) { Attributor::Collection.of(member_type) }
+    let(:attribute_options) do
+       {}
+    end
+    subject(:js){ type.as_json_schema(attribute_options: attribute_options) }
+
+    it 'adds the right attributes' do
+      expect(js.keys).to include(:type, :'x-type_name', :items)
+      expect(js[:type]).to eq(:array)
+      expect(js[:'x-type_name']).to eq('Collection')
+      expect(js[:items]).to eq(member_type.as_json_schema)
+    end
+  end
 end

data/spec/types/date_spec.rb

@@ -92,4 +92,13 @@ describe Attributor::Date do
       end
     end
   end
+  context '.as_json_schema' 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(:string)
+      expect(js[:format]).to eq(:'date')
+      expect(js[:'x-type_name']).to eq('Date')
+    end
+  end
 end

data/spec/types/date_time_spec.rb

@@ -92,4 +92,13 @@ describe Attributor::DateTime do
       end
     end
   end
+  context '.as_json_schema' do
+    subject(:js){ type.as_json_schema }
+    it 'adds the right attributes' do
+      expect(js.keys).to include(:type, :'x-type_name', :format)
+      expect(js[:type]).to eq(:string)
+      expect(js[:format]).to eq(:'date-time')
+      expect(js[:'x-type_name']).to eq('DateTime')
+    end
+  end
 end

data/spec/types/float_spec.rb

@@ -76,4 +76,12 @@ describe Attributor::Float do
       end
     end
   end
+  context '.as_json_schema' 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[:'x-type_name']).to eq('Float')
+    end
+  end  
 end