attributor 5.1.0 → 5.5

data/spec/support/integers.rb

@@ -0,0 +1,7 @@
+class PositiveIntegerType < Attributor::Integer
+
+  def self.options
+    { min: 0 }
+  end
+  
+end

data/spec/type_spec.rb

@@ -68,7 +68,7 @@ describe Attributor::Type do
       let(:context) { %w(top sub) }
 
       it 'raises an exception' do
-        expect { test_type.load(value, context) }.to raise_error(Attributor::IncompatibleTypeError, /cannot load values of type Fixnum.*while loading top.sub/)
+        expect { test_type.load(value, context) }.to raise_error(Attributor::IncompatibleTypeError, /cannot load values of type (Fixnum|Integer).*while loading top.sub/)
       end
     end
   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/class_spec.rb

@@ -1,5 +1,4 @@
 require File.join(File.dirname(__FILE__), '..', 'spec_helper.rb')
-require 'backports'
 
 describe Attributor::Class do
   subject(:type) { Attributor::Class }

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

data/spec/types/hash_spec.rb

@@ -7,6 +7,7 @@ describe Attributor::Hash do
   its(:key_type) { should be(Attributor::Object) }
   its(:value_type) { should be(Attributor::Object) }
   its(:dsl_class) { should be(Attributor::HashDSLCompiler) }
+  its(:json_schema_type) { should be(:object) }
 
   context 'attributes' do
     context 'with an exception from the definition block' do
@@ -359,7 +360,7 @@ describe Attributor::Hash do
       context 'with unknown keys in input' do
         it 'raises an error' do
           expect do
-            type.load('other_key' => :value)
+            type.load({'other_key' => :value})
           end.to raise_error(Attributor::AttributorException)
         end
       end
@@ -453,7 +454,7 @@ describe Attributor::Hash do
 
     context 'for a simple (untyped) hash' do
       it 'returns the untouched hash value' do
-        expect(type.dump(value, opts)).to eq(value)
+        expect(type.dump(value, **opts)).to eq(value)
       end
     end
 
@@ -475,7 +476,7 @@ describe Attributor::Hash do
       let(:type) { Attributor::Hash.of(key: String, value: subtype) }
 
       it 'returns a hash with the dumped values and keys' do
-        dumped_value = type.dump(value, opts)
+        dumped_value = type.dump(value, **opts)
         expect(dumped_value).to be_kind_of(::Hash)
         expect(dumped_value.keys).to match_array %w(id1 id2)
         expect(dumped_value.values).to have(2).items
@@ -487,7 +488,7 @@ describe Attributor::Hash do
         let(:value) { { id1: nil, id2: subtype.new(value2) } }
 
         it 'correctly returns nil rather than trying to dump their contents' do
-          dumped_value = type.dump(value, opts)
+          dumped_value = type.dump(value, **opts)
           expect(dumped_value).to be_kind_of(::Hash)
           expect(dumped_value.keys).to match_array %w(id1 id2)
           expect(dumped_value['id1']).to be nil
@@ -497,6 +498,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 +668,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 +680,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 +735,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
 
@@ -1096,10 +1151,10 @@ describe Attributor::Hash do
     let(:hash_of_strings) { Attributor::Hash.of(key: String) }
     let(:hash_of_symbols) { Attributor::Hash.of(key: Symbol) }
 
-    let(:merger) { hash_of_strings.load('a' => 1) }
-    let(:good_mergee) { hash_of_strings.load('b' => 2) }
-    let(:bad_mergee) { hash_of_symbols.load(c: 3) }
-    let(:result) { hash_of_strings.load('a' => 1, 'b' => 2) }
+    let(:merger) { hash_of_strings.load({'a' => 1},nil) }
+    let(:good_mergee) { hash_of_strings.load({'b' => 2},nil) }
+    let(:bad_mergee) { hash_of_symbols.load({c: 3}) }
+    let(:result) { hash_of_strings.load({'a' => 1, 'b' => 2},nil) }
 
     it 'validates that the mergee is of like type' do
       expect { merger.merge(bad_mergee) }.to raise_error(ArgumentError)
@@ -1118,4 +1173,121 @@ describe Attributor::Hash do
 
   context Attributor::InvalidDefinition do
   end
+
+
+  context '.as_json_hash' do
+    let(:example){ nil }
+    subject(:description) { type.as_json_schema(example: example) }
+    its([:type]){ should eq(:object)}
+    its([:'x-type_name']){ should eq('Hash')}
+
+    context 'for hashes with explicit key and value types' do
+      let(:key_type){ String }
+      let(:value_type){ Integer }
+
+      subject(:type) { Attributor::Hash.of(key: key_type, value: value_type) }
+
+      it 'describes the key type correctly' do
+        expect(description.keys).to include( :'x-key_type' )
+        expect(description[:'x-key_type']).to be_kind_of(::Hash)
+        expect(description[:'x-key_type'][:type]).to eq( :string )
+      end
+
+      it 'describes the value type correctly' do
+        expect(description.keys).to include( :'x-value_type' )
+        expect(description[:'x-value_type']).to be_kind_of(::Hash)
+        expect(description[:'x-value_type'][:type]).to eq( :integer )
+      end
+
+    end
+
+
+    context 'for hashes with specific keys defined' do
+      let(:block) do
+        proc do
+          key 'a string', String
+          key '1', Integer, min: 1, max: 20
+          key 'some_date', DateTime
+          key 'defaulted', String, default: 'default value'
+          requires do
+            all.of '1','some_date'
+            exclusive 'some_date', 'defaulted'
+            at_least(1).of 'a string', 'some_date'
+            at_most(2).of 'a string', 'some_date'
+            exactly(1).of 'a string', 'some_date'
+          end
+        end
+      end
+
+      let(:type) { Attributor::Hash.of(key: String).construct(block) }
+
+      it 'describes the basic type options correctly' do
+        expect(description[:type]).to eq(:object)
+        expect(description[:'x-key_type']).to eq( type: :string , 'x-type_name': 'String')
+        expect(description).to_not have_key(:'x-value_type')
+      end
+
+      it 'describes the type attributes correctly' do
+        props = description[:properties]
+
+        expect(props['a string']).to eq(type: :string, 'x-type_name': 'String')
+        expect(props['1']).to eq(type: :integer, 'x-type_name': 'Integer', minimum: 1, maximum: 20)
+        expect(props['some_date']).to eq(type: :string, 'x-type_name': 'DateTime', format: :'date-time')
+        expect(props['defaulted']).to eq(type: :string, 'x-type_name': 'String', default: 'default value')
+      end
+
+      it 'describes the attribute requirements correctly' do
+        reqs = description[:required]
+        expect(reqs).to be_kind_of(Array)
+        expect(reqs).to eq( ['1','some_date'] )
+      end
+
+      it 'describes the extended requirements correctly' do
+        reqs = description[:'x-requirements']
+        expect(reqs).to be_kind_of(Array)
+        expect(reqs.size).to be(5)
+        expect(reqs).to include( type: :all, attributes: ['1','some_date'] )
+        expect(reqs).to include( type: :exclusive, attributes: ['some_date','defaulted'] )
+        expect(reqs).to include( type: :at_least, attributes: ['a string','some_date'], count: 1 )
+        expect(reqs).to include( type: :at_most, attributes: ['a string','some_date'], count: 2 )
+        expect(reqs).to include( type: :exactly, attributes: ['a string','some_date'], count: 1 )
+      end
+
+      context 'merging requires.all with attribute required: true' do
+        let(:block) do
+          proc do
+            key 'required string', String, required: true
+            key '1', Integer
+            key 'some_date', DateTime
+            requires do
+              all.of 'some_date'
+            end
+          end
+        end
+        it 'includes attributes with required: true into :required' do
+          expect(description[:required].size).to eq(2)
+          expect(description[:required]).to include( 'required string','some_date' )
+        end
+
+        it 'includes attributes with required: true into the :all requirements' do
+          req_all = description[:'x-requirements'].select{|r| r[:type] == :all}.first
+          expect(req_all[:attributes]).to include( 'required string','some_date' )
+        end
+      end
+
+
+      context 'with an example' do
+        let(:example){ type.example }
+
+        it 'should have the matching example for each leaf key' do
+          expect(description[:properties].keys).to include(*type.keys.keys)
+          description[:properties].each do |name,sub_description|
+            expect(sub_description).to have_key(:example)
+            val = type.attributes[name].dump(example[name])
+            expect(sub_description[:example]).to eq val
+          end
+        end
+      end
+    end
+  end
 end

data/spec/types/integer_spec.rb

@@ -97,7 +97,7 @@ describe Attributor::Integer do
           it "raises for the invalid range [#{min.inspect}, #{max.inspect}]" do
             opts = { options: { max: max, min: min } }
             expect do
-              type.example(nil, opts)
+              type.example(nil, **opts)
             end.to raise_error(Attributor::AttributorException, "Invalid range: [#{min.inspect}, #{max.inspect}]")
           end
         end
@@ -146,4 +146,13 @@ describe Attributor::Integer do
       end
     end
   end
+
+  context '.as_json_schema' do
+    subject(:js){ type.as_json_schema }
+    it 'adds the right stuff' do
+      expect(js.keys).to include(:type, :'x-type_name')
+      expect(js[:type]).to eq(:integer)
+      expect(js[:'x-type_name']).to eq('Integer')
+    end
+  end
 end

data/spec/types/model_spec.rb

@@ -369,7 +369,7 @@ describe Attributor::Model do
     end
 
     context 'for models using the "requires" DSL' do
-      subject(:address) { Address.load(state: 'CA') }
+      subject(:address) { Address.load({state: 'CA'}) }
       its(:validate) { should_not be_empty }
       its(:validate) { should include 'Key name is required for $.' }
     end
@@ -380,8 +380,8 @@ describe Attributor::Model do
       end
 
       context 'that are both invalid' do
-        subject(:person) { Person.load(name: 'Joe', title: 'dude', okay: true) }
-        let(:address) { Address.load(name: '1 Main St', state: 'ME') }
+        subject(:person) { Person.load({name: 'Joe', title: 'dude', okay: true}) }
+        let(:address) { Address.load({name: '1 Main St', state: 'ME'}) }
         before do
           person.address = address
           address.person = person
@@ -413,6 +413,17 @@ describe Attributor::Model do
         expect(person.address.person).to be(person)
         expect(output[:address][:person]).to eq(Attributor::Model::CIRCULAR_REFERENCE_MARKER)
       end
+
+      it 'passes kwargs' do
+        person.class.attributes.values.each do |attr|
+          expect(attr).to receive(:dump).with(
+            anything,
+            context: anything,
+            custom_arg: :custom_value
+          )
+        end
+        person.dump(custom_arg: :custom_value)
+      end
     end
   end
 

data/spec/types/string_spec.rb

@@ -64,4 +64,14 @@ describe Attributor::String do
       end.to raise_error(Attributor::IncompatibleTypeError)
     end
   end
+
+  context '.as_json_schema' do
+    subject(:js){ type.as_json_schema(attribute_options: { regexp: /^Foobar$/ }) }
+    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('String')
+      expect(js[:pattern]).to eq('^Foobar$')
+    end
+  end
 end