attributor 5.2.0 → 5.6

data/spec/dsl_compiler_spec.rb

@@ -4,7 +4,7 @@ describe Attributor::DSLCompiler do
   let(:target) { double('model', attributes: {}) }
 
   let(:dsl_compiler_options) { {} }
-  subject(:dsl_compiler) { Attributor::DSLCompiler.new(target, dsl_compiler_options) }
+  subject(:dsl_compiler) { Attributor::DSLCompiler.new(target, **dsl_compiler_options) }
 
   let(:attribute_name) { :name }
   let(:type) { Attributor::String }
@@ -35,7 +35,7 @@ describe Attributor::DSLCompiler do
 
         it 'creates an attribute given a name, type, and options' do
           expect(Attributor::Attribute).to receive(:new).with(expected_type, expected_options)
-          dsl_compiler.attribute(attribute_name, type, attribute_options)
+          dsl_compiler.attribute(attribute_name, type, **attribute_options)
         end
       end
 
@@ -60,11 +60,11 @@ describe Attributor::DSLCompiler do
           end
 
           it 'creates an attribute with the inherited type and merged options' do
-            dsl_compiler.attribute(attribute_name, attribute_options)
+            dsl_compiler.attribute(attribute_name, **attribute_options)
           end
 
           it 'accepts explicit nil type' do
-            dsl_compiler.attribute(attribute_name, nil, attribute_options)
+            dsl_compiler.attribute(attribute_name, nil, **attribute_options)
           end
 
           context 'but with the attribute also specifying a reference' do
@@ -73,7 +73,7 @@ describe Attributor::DSLCompiler do
             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)
+              dsl_compiler.attribute(attribute_name, **attribute_options)
             end
           end
         end
@@ -113,12 +113,12 @@ describe Attributor::DSLCompiler do
         it 'sets the type of the attribute to Struct' do
           expect(Attributor::Attribute).to receive(:new)
             .with(expected_type, description: 'The turkey', reference: Turkey)
-          dsl_compiler.attribute(attribute_name, attribute_options, &attribute_block)
+          dsl_compiler.attribute(attribute_name, **attribute_options, &attribute_block)
         end
 
         it 'passes the correct reference to the created attribute' do
           expect(Attributor::Attribute).to receive(:new).with(expected_type, expected_options)
-          dsl_compiler.attribute(attribute_name, type, attribute_options, &attribute_block)
+          dsl_compiler.attribute(attribute_name, type, **attribute_options, &attribute_block)
         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

@@ -4,7 +4,7 @@ describe Attributor::HashDSLCompiler do
   let(:target) { double('model', attributes: {}) }
 
   let(:dsl_compiler_options) { {} }
-  subject(:dsl_compiler) { Attributor::HashDSLCompiler.new(target, dsl_compiler_options) }
+  subject(:dsl_compiler) { Attributor::HashDSLCompiler.new(target, **dsl_compiler_options) }
 
   it 'returns the requirements DSL attached to the right target' do
     req_dsl = dsl_compiler._requirements_dsl
@@ -103,7 +103,7 @@ describe Attributor::HashDSLCompiler do
     end
 
     context 'Requirement#validate' do
-      let(:requirement) { req_class.new(arguments) }
+      let(:requirement) { req_class.new(**arguments) }
       let(:subject) { requirement.validate(value, ['$'], nil) }
 
       context 'for :all' do

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
@@ -706,7 +707,7 @@ describe Attributor::Hash do
           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"})
+          ex = type.example(nil,most2: "data")
           expect(ex.keys).to match([:req1, :req2, :exc3, :least1, :least2, :most2])
         end
       end
@@ -1150,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)
@@ -1172,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