attributor 5.4 → 5.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA256:
-  metadata.gz: bb9d8a77a4e71c5f44cc2eaa6559c7d40882c88ec675b0400170d961386d66c1
-  data.tar.gz: 0b4d4bec370cbca4fa15d61dd08b0bc9b2cdcb8f1f0d39d21287e7471f60075e
+SHA1:
+  metadata.gz: 30cd524aa1a60bb34487915e2201e20b075f8eaf
+  data.tar.gz: 4a9776a1a772b00636a46caec55f583aa75d54f4
 SHA512:
-  metadata.gz: 78a4367ada6bebcb2a164da33b08e05bd0c20207d11df7631b700346bb3e4ec74df47bef3373178cbd619a2f0252609c59586a1fb46c0913830a57b547361b67
-  data.tar.gz: e2a0fa2ecb088ff61c184624fcadfcc992d1fd60c5694727e8ffd594be1188ee6d60e2b14d7cc1daab4a9e8fbd67b584612d3be6e7574fbda4cfca004a182e00
+  metadata.gz: a5a4832825c92b5530352b626ae281c134aa215f167c633a7912b22cee2927fde696d07b92bfd6159b0e88db4dc69b19b38a289181cb523e0c961005608e4f86
+  data.tar.gz: a44680f8509acf463ac0c4a22a872db8456300745d01b5c4a31a597bd17760d995e5d6ce26120d998f8df5c4c06fe2d11e7e00c35959f6c987860059425af663

data/CHANGELOG.md

@@ -2,6 +2,10 @@
 
 ## next
 
+## 5.5 (21/08/2020)
+
+- JSON-schema support. Enhanced all of the types to suppport describing themselves as JSON-schema format (`.as_json_schema`). This description includes a few `x-*` extensions to capture some information that Attributor supports, that JSON-schema does not.
+
 ## 5.3 (24/04/2020)
 
 - Fixed deprecation warnings in Ruby 2.7

data/lib/attributor.rb

@@ -2,7 +2,7 @@ require 'json'
 require 'randexp'
 
 require 'hashie'
-
+require 'active_support/concern'
 require 'digest/sha1'
 
 module Attributor

data/lib/attributor/attribute.rb

@@ -93,12 +93,12 @@ module Attributor
 
     TOP_LEVEL_OPTIONS = [:description, :values, :default, :example, :required, :required_if, :custom_data].freeze
     INTERNAL_OPTIONS = [:dsl_compiler, :dsl_compiler_options].freeze # Options we don't want to expose when describing attributes
-
-    def describe(shallow = true, example: nil)
-      description = {}
+    JSON_SCHEMA_UNSUPPORTED_OPTIONS = [ :required, :required_if ].freeze
+    def describe(shallow=true, example: nil)
+      description = { }
       # Clone the common options
       TOP_LEVEL_OPTIONS.each do |option_name|
-        description[option_name] = options[option_name] if options.key? option_name
+        description[option_name] = self.describe_option(option_name) if self.options.has_key? option_name
       end
 
       # Make sure this option definition is not mistaken for the real generated example
@@ -109,7 +109,7 @@ module Attributor
       special_options = options.keys - TOP_LEVEL_OPTIONS - INTERNAL_OPTIONS
       description[:options] = {} unless special_options.empty?
       special_options.each do |opt_name|
-        description[:options][opt_name] = options[opt_name]
+        description[:options][opt_name] = self.describe_option(opt_name)
       end
       # Change the reference option to the actual class name.
       if (reference = options[:reference])
@@ -146,8 +146,37 @@ module Attributor
       load(generated, context)
     end
 
-    def example(context = nil, parent: nil, values: {})
-      raise ArgumentError, 'attribute example cannot take a context of type String' if context.is_a? ::String
+    def describe_option( option_name )
+      self.type.describe_option( option_name, self.options[option_name] )
+    end
+
+    # FiXME: pass and utilize the "shallow" parameter
+    #required
+    #options
+    #type
+    #example
+    # UTILIZE THIS SITE! http://jsonschema.net/#/
+    def as_json_schema(shallow: true, example: nil)
+      description = self.type.as_json_schema(shallow: shallow, example: example, attribute_options: self.options )
+
+      description[:description] = self.options[:description] if self.options[:description]
+      description[:enum] = self.options[:values] if self.options[:values]
+      description[:default] = self.options[:default] if self.options[:default]
+      #TODO      description[:title] = "TODO: do we want to use a title??..."
+
+      # Change the reference option to the actual class name.
+      if ( reference = self.options[:reference] )
+        description[:'x-reference'] = reference.name
+      end
+
+      # TODO: not sure if that's correct (we used to get it from the described hash...
+      description[:example] = self.dump(example) if example
+
+      description
+    end
+
+    def example(context=nil, parent: nil, values:{})
+      raise ArgumentError, "attribute example cannot take a context of type String" if (context.is_a? ::String )
       if context
         ctx = Attributor.humanize_context(context)
         seed, = Digest::SHA1.digest(ctx).unpack('QQ')

data/lib/attributor/extras/field_selector.rb

@@ -12,6 +12,10 @@ module Attributor
 
     include Attributor::Type
 
+    def self.json_schema_type
+      :string
+    end
+
     def self.native_type
       ::Hash
     end

data/lib/attributor/families/numeric.rb

@@ -1,15 +1,28 @@
 # Abstract type for the 'numeric' family
 
 module Attributor
-  class Numeric
+  module Numeric
+    extend ActiveSupport::Concern
     include Type
 
-    def self.native_type
-      raise NotImplementedError
-    end
+    module ClassMethods
+      
+      def native_type
+        raise NotImplementedError
+      end
+
+      def family
+        'numeric'
+      end
 
-    def self.family
-      'numeric'
+      def as_json_schema( shallow: false, example: nil, attribute_options: {} )
+        h = super
+        opts = ( self.respond_to?(:options) ) ? self.options.merge( attribute_options ) : attribute_options
+        h[:minimum] = opts[:min] if opts[:min]
+        h[:maximum] = opts[:max] if opts[:max]
+        # We're not explicitly setting false to exclusiveMinimum and exclusiveMaximum (as that's the default)
+        h
+      end
     end
   end
 end

data/lib/attributor/families/temporal.rb

@@ -1,19 +1,26 @@
 # Abstract type for the 'temporal' family
 
 module Attributor
-  class Temporal
+  module Temporal
+    extend ActiveSupport::Concern
     include Type
 
-    def self.native_type
-      raise NotImplementedError
-    end
+    module ClassMethods
+      def native_type
+        raise NotImplementedError
+      end
 
-    def self.family
-      'temporal'
-    end
+      def family
+        'temporal'
+      end
+
+      def dump(value, **_opts)
+        value && value.iso8601
+      end
 
-    def self.dump(value, **_opts)
-      value && value.iso8601
+      def json_schema_type
+        :string
+      end
     end
   end
 end

data/lib/attributor/type.rb

@@ -2,9 +2,7 @@ module Attributor
   # It is the abstract base class to hold an attribute, both a leaf and a container (hash/Array...)
   # TODO: should this be a mixin since it is an abstract class?
   module Type
-    def self.included(klass)
-      klass.extend(ClassMethods)
-    end
+    extend ActiveSupport::Concern
 
     module ClassMethods
       # Does this type support the generation of subtypes?
@@ -124,6 +122,31 @@ module Attributor
       def family
         'any'
       end
+
+      # Default no format in case it's a string type
+      def json_schema_string_format
+        nil
+      end
+  
+      def as_json_schema( shallow: false, example: nil, attribute_options: {} )
+        type_name = self.ancestors.find { |k| k.name && !k.name.empty? }.name
+        hash = { type: json_schema_type, 'x-type_name': type_name.gsub( Attributor::MODULE_PREFIX_REGEX, '' )}
+        # Add a format, if the type has defined
+        if hash[:type] == :string && the_format = json_schema_string_format
+          hash[:format] = the_format
+        end
+        hash
+      end
+
+      def describe_option( option_name, option_value )
+        return case option_name
+        when :description
+          option_value
+        else
+          option_value  # By default, describing an option returns the hash with the specification
+        end
+      end
+
     end
   end
 end

data/lib/attributor/types/bigdecimal.rb

@@ -1,7 +1,8 @@
 require 'bigdecimal'
 
 module Attributor
-  class BigDecimal < Numeric
+  class BigDecimal 
+    include Numeric
     def self.native_type
       ::BigDecimal
     end
@@ -16,5 +17,9 @@ module Attributor
       return BigDecimal(value, 10) if value.is_a?(::Float)
       BigDecimal(value)
     end
+
+    def self.json_schema_type
+      :number
+    end
   end
 end

data/lib/attributor/types/boolean.rb

@@ -26,5 +26,10 @@ module Attributor
     def self.family
       'boolean'
     end
+
+    def self.json_schema_type
+      :boolean
+    end
+
   end
 end

data/lib/attributor/types/collection.rb

@@ -117,6 +117,22 @@ module Attributor
       hash
     end
 
+    def self.json_schema_type
+      :array
+    end
+
+    def self.as_json_schema( shallow: false, example: nil, attribute_options: {} )
+      hash = super
+      opts = self.options.merge( attribute_options )
+      hash[:description] = opts[:description] if opts[:description]
+      hash[:default] = opts[:default] if opts[:default]
+
+      #hash[:examples] = [ example.dump ] if example
+      member_example = example && example.first
+      hash[:items] = member_attribute.as_json_schema(example: member_example)
+      hash
+    end
+
     def self.constructable?
       true
     end

data/lib/attributor/types/csv.rb

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

data/lib/attributor/types/date.rb

@@ -1,7 +1,9 @@
 require 'date'
 
 module Attributor
-  class Date < Temporal
+  class Date
+    include Temporal
+
     def self.native_type
       ::Date
     end
@@ -27,5 +29,9 @@ module Attributor
         raise CoercionError.new(context: context, from: value.class, to: self, value: value)
       end
     end
+
+    def self.json_schema_string_format
+      :date
+    end
   end
 end

data/lib/attributor/types/date_time.rb

@@ -5,7 +5,9 @@ require_relative '../exceptions'
 require 'date'
 
 module Attributor
-  class DateTime < Temporal
+  class DateTime
+    include Temporal
+
     def self.native_type
       ::DateTime
     end
@@ -27,5 +29,9 @@ module Attributor
         raise Attributor::DeserializationError.new(context: context, from: value.class, encoding: 'DateTime', value: value)
       end
     end
+
+    def self.json_schema_string_format
+      :'date-time'
+    end
   end
 end

data/lib/attributor/types/float.rb

@@ -2,8 +2,9 @@
 # See: http://ruby-doc.org/core-2.1.0/Float.html
 
 module Attributor
+
   class Float
-    include Type
+    include Numeric
 
     def self.native_type
       ::Float
@@ -22,8 +23,8 @@ module Attributor
       super
     end
 
-    def self.family
-      'numeric'
+    def self.json_schema_type
+      :number
     end
   end
 end

data/lib/attributor/types/hash.rb

@@ -437,11 +437,11 @@ module Attributor
 
       if keys.any?
         # Spit keys if it's the root or if it's an anonymous structures
-        if !shallow || name.nil?
-          required_names = []
+        if ( !shallow || self.name == nil)
+          required_names_from_attr = []
           # FIXME: change to :keys when the praxis doc browser supports displaying those
-          hash[:attributes] = keys.each_with_object({}) do |(sub_name, sub_attribute), sub_attributes|
-            required_names << sub_name if sub_attribute.options[:required] == true
+          hash[:attributes] = self.keys.each_with_object({}) do |(sub_name, sub_attribute), sub_attributes|
+            required_names_from_attr << sub_name if sub_attribute.options[:required] == true
             sub_example = example.get(sub_name) if example
             sub_attributes[sub_name] = sub_attribute.describe(true, example: sub_example)
           end
@@ -449,14 +449,14 @@ module Attributor
             described_req = req.describe(shallow)
             if described_req[:type] == :all
               # Add the names of the attributes that have the required flag too
-              described_req[:attributes] |= required_names
-              required_names = []
+              described_req[:attributes] |= required_names_from_attr
+              required_names_from_attr = []
             end
             list << described_req
           end
           # Make sure we create an :all requirement, if there wasn't one so we can add the required: true attributes
-          unless required_names.empty?
-            hash[:requirements] << { type: :all, attributes: required_names }
+          unless required_names_from_attr.empty?
+            hash[:requirements] << {type: :all, attributes: required_names_from_attr }
           end
         end
       else
@@ -467,6 +467,61 @@ module Attributor
       hash
     end
 
+    def self.as_json_schema( shallow: false, example: nil, attribute_options: {} )
+      hash = super
+      opts = self.options.merge( attribute_options )
+
+      if key_type
+        hash[:'x-key_type'] = key_type.as_json_schema
+      end
+
+      if self.keys.any?
+        # Spit keys if it's the root or if it's an anonymous structures
+        if ( !shallow || self.name == nil)
+          required_names_from_attr = []
+          # FIXME: change to :keys when the praxis doc browser supports displaying those
+          hash[:properties] = self.keys.each_with_object({}) do |(sub_name, sub_attribute), sub_attributes|
+            required_names_from_attr << sub_name if sub_attribute.options[:required] == true
+            sub_example = example.get(sub_name) if example
+            sub_attributes[sub_name] = sub_attribute.as_json_schema(shallow: true, example: sub_example)
+          end
+
+          # Expose the more complex requirements to in the x-tended attribute
+          extended_requirements = self.requirements.each_with_object([]) do |req, list|
+            described_req = req.describe(shallow)
+            if described_req[:type] == :all
+              # Add the names of the attributes that have the required flag too
+              described_req[:attributes] |= required_names_from_attr
+              required_names_from_attr = []
+            end
+            list << described_req
+          end
+          all = extended_requirements.find{|r| r[:type] == :all }
+          if ( all && !all[:attributes].empty? )
+            hash[:required] = all[:attributes]
+          end
+          hash[:'x-requirements'] = extended_requirements unless extended_requirements.empty?
+        end
+      else
+        hash[:'x-value_type'] = value_type.as_json_schema(shallow:true)
+      end
+
+      if opts[:allow_extra]
+        hash[:additionalProperties] = if value_type == Attributor::Object
+          true
+        else
+          value_type.as_json_schema(shallow: true)
+        end
+      end
+      # TODO: minProperties and maxProperties and patternProperties
+      # TODO: map our required_if (and possible our above requirements 'at_least...' to json schema dependencies)
+      hash
+    end
+
+    def self.json_schema_type
+      :object
+    end
+
     # TODO: Think about the format of the subcontexts to use: let's use .at(key.to_s)
     attr_reader :contents
 

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/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'
 

data/lib/attributor/types/string.rb

@@ -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/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
@@ -35,5 +35,9 @@ module Attributor
         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

data/lib/attributor/version.rb

@@ -1,3 +1,3 @@
 module Attributor
-  VERSION = '5.4'.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' } }

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/support/integers.rb

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

@@ -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/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: '5.5'
 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: 2020-08-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: hashie
@@ -361,6 +361,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,7 +407,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubyforge_project: 
+rubygems_version: 2.6.14
 signing_key: 
 specification_version: 4
 summary: A powerful attribute and type management library for Ruby
@@ -422,6 +424,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