attributor 5.4 → 6.0

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
@@ -513,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 }
@@ -533,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
 
@@ -590,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
@@ -609,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
 
@@ -627,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
 
@@ -650,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
 
@@ -675,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
@@ -1172,4 +1214,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

@@ -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

@@ -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

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

data/spec/types/temporal_spec.rb

@@ -1,7 +1,11 @@
 require 'spec_helper'
 
 describe Attributor::Temporal do
-  subject(:type) { Attributor::Temporal }
+  subject(:type) do
+    Class.new do
+      include Attributor::Temporal
+    end
+  end
 
   it 'raises an exception for native_type' do
     expect { type.native_type }.to raise_error(NotImplementedError)

data/spec/types/time_spec.rb

@@ -90,4 +90,13 @@ describe Attributor::Time 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(:'time')
+      expect(js[:'x-type_name']).to eq('Time')
+    end
+  end  
 end

data/spec/types/uri_spec.rb

@@ -109,4 +109,13 @@ describe Attributor::URI 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(:uri)
+      expect(js[:'x-type_name']).to eq('URI')
+    end
+  end  
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: attributor
 version: !ruby/object:Gem::Version
-  version: '5.4'
+  version: '6.0'
 platform: ruby
 authors:
 - Josep M. Blanquer
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-05-01 00:00:00.000000000 Z
+date: 2021-11-22 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
@@ -361,6 +359,7 @@ files:
 - spec/smart_attribute_selector_spec.rb
 - spec/spec_helper.rb
 - spec/support/hashes.rb
+- spec/support/integers.rb
 - spec/support/models.rb
 - spec/support/polymorphics.rb
 - spec/type_spec.rb
@@ -406,12 +405,11 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+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
@@ -422,6 +420,7 @@ test_files:
 - spec/smart_attribute_selector_spec.rb
 - spec/spec_helper.rb
 - spec/support/hashes.rb
+- spec/support/integers.rb
 - spec/support/models.rb
 - spec/support/polymorphics.rb
 - spec/type_spec.rb

data/lib/attributor/attribute_resolver.rb

@@ -1,111 +0,0 @@
-require 'ostruct'
-
-module Attributor
-  class AttributeResolver
-    ROOT_PREFIX = '$'.freeze
-    COLLECTION_INDEX_KEY = /^at\((\d+)\)$/
-
-    class Data < ::Hash
-      include Hashie::Extensions::MethodReader
-    end
-
-    attr_reader :data
-
-    def initialize
-      @data = Data.new
-    end
-
-    def query!(key_path, path_prefix = ROOT_PREFIX)
-      # If the incoming key_path is not an absolute path, append the given prefix
-      # NOTE: Need to index key_path by range here because Ruby 1.8 returns a
-      # FixNum for the ASCII code, not the actual character, when indexing by a number.
-      unless key_path[0..0] == ROOT_PREFIX
-        # TODO: prepend path_prefix to path_prefix if it did not include it? hm.
-        key_path = path_prefix + SEPARATOR + key_path
-      end
-
-      # Discard the initial element, which should always be ROOT_PREFIX at this point
-      _root, *path = key_path.split(SEPARATOR)
-
-      # Follow the hierarchy path to the requested node and return it:
-      # Example path => ["instance", "ssh_key", "name"]
-      # Example @data => {"instance" => { "ssh_key" => { "name" => "foobar" } }}
-      #
-      # at(n) is a collection index:
-      # Example path => ["filters", "at(0)", "type"]
-      # Example data => {"filters" => [{ "type" => "instance:tag" }]}
-      #
-      result = path.inject(@data) do |hash, key|
-        return nil if hash.nil?
-        if (match = key.match(COLLECTION_INDEX_KEY))
-          hash[match[1].to_i]
-        else
-          hash.send key
-        end
-      end
-      result
-    end
-
-    # Query for a certain key in the attribute hierarchy
-    #
-    # @param [String] key_path The name of the key to query and its path
-    # @param [String] path_prefix
-    #
-    # @return [String] The value of the specified attribute/key
-    #
-    def query(key_path, path_prefix = ROOT_PREFIX)
-      query!(key_path, path_prefix)
-    rescue NoMethodError
-      nil
-    end
-
-    def register(key_path, value)
-      if key_path.split(SEPARATOR).size > 1
-        raise AttributorException, "can only register top-level attributes. got: #{key_path}"
-      end
-
-      @data[key_path] = value
-    end
-
-    # Checks that the the condition is met. This means the attribute identified
-    # by path_prefix and key_path satisfies the optional predicate, which when
-    # nil simply checks for existence.
-    #
-    # @param path_prefix [String]
-    # @param key_path [String]
-    # @param predicate [String|Regexp|Proc|NilClass]
-    #
-    # @returns [Boolean] True if :required_if condition is met, false otherwise
-    #
-    # @raise [AttributorException] When an unsupported predicate is passed
-    #
-    def check(path_prefix, key_path, predicate = nil)
-      value = query(key_path, path_prefix)
-
-      # we have a value, any value, which is good enough given no predicate
-      return true if !value.nil? && predicate.nil?
-
-      case predicate
-      when ::String, ::Regexp, ::Integer, ::Float, ::DateTime, true, false
-        return predicate === value
-      when ::Proc
-        # Cannot use === here as above due to different behavior in Ruby 1.8
-        return predicate.call(value)
-      when nil
-        return !value.nil?
-      else
-        raise AttributorException, "predicate not supported: #{predicate.inspect}"
-      end
-    end
-
-    # TODO: kill this when we also kill Taylor's IdentityMap.current
-    def self.current=(resolver)
-      Thread.current[:_attributor_attribute_resolver] = resolver
-    end
-
-    def self.current
-      raise AttributorException, 'No AttributeResolver set.' unless Thread.current[:_attributor_attribute_resolver]
-      Thread.current[:_attributor_attribute_resolver]
-    end
-  end
-end