attributor 5.1.0 → 5.5

data/lib/attributor/types/integer.rb

@@ -1,7 +1,9 @@
 
 
 module Attributor
-  class Integer < Numeric
+  class Integer
+    include Attributor::Numeric
+
     EXAMPLE_RANGE = 1000
 
     def self.native_type
@@ -53,5 +55,9 @@ module Attributor
       end
       true
     end
+
+    def self.json_schema_type
+      :integer
+    end
   end
 end

data/lib/attributor/types/model.rb

@@ -105,7 +105,7 @@ module Attributor
         result = new
         result.extend(ExampleMixin)
 
-        result.lazy_attributes = example_contents(context, result, values)
+        result.lazy_attributes = example_contents(context, result, **values)
       else
         result = new
       end
@@ -192,7 +192,7 @@ module Attributor
           next
         end
 
-        hash[name.to_sym] = attribute.dump(value, context: context + [name])
+        hash[name.to_sym] = attribute.dump(value, context: context + [name], **_opts)
       end
     ensure
       @dumping = false

data/lib/attributor/types/object.rb

@@ -13,5 +13,10 @@ module Attributor
     def self.example(_context = nil, options: {})
       'An Object'
     end
+        
+    def self.json_schema_type
+      :object #FIXME: not sure this is the most appropriate, since an Attributor::Object can be anything
+    end
+
   end
 end

data/lib/attributor/types/polymorphic.rb

@@ -1,4 +1,3 @@
-require 'active_support'
 
 require_relative '../exceptions'
 
@@ -95,7 +94,9 @@ module Attributor
         value
       elsif value.is_a?(::String)
         decode_json(value, context)
-      elsif value.respond_to?(:to_hash)
+      elsif value.respond_to?(:to_h)
+        value.to_h
+      elsif value.respond_to?(:to_hash) # Deprecate this in lieu of to_h only?
         value.to_hash
       else
         raise Attributor::IncompatibleTypeError, context: context, value_type: value.class, type: self

data/lib/attributor/types/string.rb

@@ -8,7 +8,7 @@ module Attributor
 
     def self.load(value, context = Attributor::DEFAULT_ROOT_CONTEXT, **options)
       if value.is_a?(Enumerable)
-        raise IncompatibleTypeError, context: context, value_type: value.class, type: self
+        raise IncompatibleTypeError.new(context: context, value_type: value.class, type: self)
       end
 
       value && String(value)
@@ -32,5 +32,24 @@ module Attributor
     def self.family
       'string'
     end
+
+    def self.json_schema_type
+      :string
+    end
+    
+    # TODO: we're passing the attribute options for now...might need to rethink ...although these are type-specific...
+    # TODO: multipleOf, minimum, maximum, exclusiveMinimum and exclusiveMaximum
+    def self.as_json_schema( shallow: false, example: nil, attribute_options: {} )
+      h = super
+      opts = ( self.respond_to?(:options) ) ? self.options.merge( attribute_options ) : attribute_options
+      h[:pattern] = self.human_readable_regexp(opts[:regexp]) if opts[:regexp]
+      # TODO: minLength, maxLength
+      h
+    end
+
+    def self.human_readable_regexp( reg )
+      return $1 if reg.to_s =~ /\(\?[^:]+:(.+)\)/
+      reg
+    end
   end
 end

data/lib/attributor/types/struct.rb

@@ -26,7 +26,7 @@ module Attributor
       end
 
       ::Class.new(self) do
-        attributes options, &attribute_definition
+        attributes **options, &attribute_definition
       end
     end
 

data/lib/attributor/types/symbol.rb

@@ -19,5 +19,10 @@ module Attributor
     def self.family
       String.family
     end
+
+    def self.json_schema_type
+      :string
+    end
+
   end
 end

data/lib/attributor/types/tempfile.rb

@@ -38,5 +38,9 @@ module Attributor
     def self.family
       String.family
     end
+
+    def self.json_schema_type
+      :string
+    end
   end
 end

data/lib/attributor/types/time.rb

@@ -1,8 +1,8 @@
 require 'date'
 
 module Attributor
-  class Time < Temporal
-    include Type
+  class Time
+    include Temporal
 
     def self.native_type
       ::Time
@@ -29,11 +29,15 @@ module Attributor
         begin
           return ::Time.parse(value)
         rescue ArgumentError
-          raise Attributor::DeserializationError, context: context, from: value.class, encoding: 'Time', value: value
+          raise Attributor::DeserializationError.new(context: context, from: value.class, encoding: 'Time', value: value)
         end
       else
         raise CoercionError, context: context, from: value.class, to: self, value: value
       end
     end
+
+    def self.json_schema_string_format
+      :time
+    end
   end
 end

data/lib/attributor/types/uri.rb

@@ -22,6 +22,14 @@ module Attributor
       ::URI::Generic
     end
 
+    def self.json_schema_type
+      :string
+    end
+
+    def self.json_schema_string_format
+      :uri
+    end
+
     def self.example(_context = nil, options: {})
       URI(Randgen.uri)
     end
@@ -34,7 +42,7 @@ module Attributor
       when ::String
         URI(value)
       else
-        raise CoercionError, context: context, from: value.class, to: self, value: value
+        raise CoercionError.new(context: context, from: value.class, to: self, value: value)
       end
     end
 

data/lib/attributor/version.rb

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

data/spec/attribute_spec.rb

@@ -36,17 +36,48 @@ 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.merge!(common)
-      h[:options] = { min: 0 }
+      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
     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' } }
@@ -313,7 +344,11 @@ describe Attributor::Attribute do
     let(:value) { '1' }
 
     it 'delegates to type.load' do
-      expect(type).to receive(:load).with(value, context, {})
+      # Need to add the "anything" of the 3rd element, as in ruby < 2.7 it comes as an empty hash
+      expect(type).to receive(:load) do |v, c, _other|
+        expect(v).to eq(value)
+        expect(c).to eq(context)
+      end   
       attribute.load(value, context)
     end
 

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,21 @@ 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
+            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
 
@@ -103,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/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