json_model_rb 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6055ccf369735b5c3461df4c1e1c84fb376bbfb56db264c4b2cff411a0408f7b
-  data.tar.gz: 269014c71581e5fa7053b00e37cd0e9faa854b2af11b243aab322da3673cc758
+  metadata.gz: 9599ecfecdb61edf6173927d8e33bf9a96686fe765aa94274611788eff07312a
+  data.tar.gz: 160000519dda11b0ce29648dd17d12436e86514acbc013de01da96f23949effe
 SHA512:
-  metadata.gz: 9e9145acb6866d32cd0a34a507bf9b30658c7197e5098e630f679bd874697639d66cf17c60fd9b8534418c6f01c7470508193077e260d935845b6275ee5f9636
-  data.tar.gz: 1d5c2c8cd76cb864be16eb30787a53349ccc5c28f08d159f6e1984e87264c91dea759184ed7f67ff61720bf912e92deeaa1a014c560338ca86694ab5288585c4
+  metadata.gz: 12a4b646df7225003ec60e07dccbbb6c5115e405736af120712d0659fc14fea268373701e30f7f3e2b07f3f095b3f0a797946e97794d07b60b15ea368d48b7cf
+  data.tar.gz: dee7c155478f1e4532348e481587d00045b325744e0014638acfe4c28074f0569f19e1210a01f54de848f4eea3ce4b42d3d2830a0f81d2f1f9abae7aa1faeca6

data/lib/json_model/errors/type_error.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module JsonModel
+  module Errors
+    class TypeError < Error
+    end
+  end
+end

data/lib/json_model/errors.rb

@@ -2,4 +2,5 @@
 
 require_relative('errors/error')
 require_relative('errors/invalid_ref_mode_error')
+require_relative('errors/type_error')
 require_relative('errors/unknown_attribute_error')

data/lib/json_model/properties.rb

@@ -17,8 +17,8 @@ module JsonModel
       # @param [Object] type
       # @param [Hash] options
       def property(name, type:, **options)
-        property_options = options.slice(:default, :optional, :ref_mode)
-        resolved_type = TypeSpec.resolve(type, **options.except(:default, :optional, :ref_mode))
+        property_options = options.slice(:default, :optional, :ref_mode, :as)
+        resolved_type = TypeSpec.resolve(type, **options.except(:default, :optional, :ref_mode, :as))
         add_property(name, type: resolved_type, **property_options)
         descendants.each { |subclass| subclass.add_property(name, type: resolved_type, **property_options) }
       end
@@ -54,7 +54,7 @@ module JsonModel
 
       # @param [Property] property
       def define_setter(property)
-        define_method("#{property.name}=") { |value| attributes[property.name] = value }
+        define_method("#{property.name}=") { |value| attributes[property.name] = property.type.cast(value) }
       end
 
       # @param [Property] property

data/lib/json_model/schema_meta.rb

@@ -23,9 +23,20 @@ module JsonModel
       end
 
       schema_id(name)
+      additional_properties(false)
     end
 
     class_methods do
+      # @param [String, nil] description
+      # @return [String, nil]
+      def description(description = nil)
+        if description
+          meta_attributes[:description] = description
+        else
+          meta_attributes[:description]
+        end
+      end
+
       # @param [String, nil] id
       # @return [String, nil]
       def schema_id(id = nil)

data/lib/json_model/type_spec/array.rb

@@ -45,6 +45,12 @@ module JsonModel
         @type.referenced_schemas
       end
 
+      # @param [::Object] json
+      # @return [::Object]
+      def cast(json)
+        json.map { |item| @type.cast(item) }
+      end
+
       private
 
       # @param [Symbol] name

data/lib/json_model/type_spec/composition/all_of.rb

@@ -9,6 +9,20 @@ module JsonModel
         def initialize(*types, **options)
           super(:allOf, *types, **options)
         end
+
+        # @param [::Object] json
+        # @return [::Object]
+        def cast(json)
+          if json.nil?
+            return nil
+          end
+
+          @types.map do |type|
+            type.cast(json)
+          rescue StandardError
+            raise(Errors::TypeError, "Value #{json.inspect} cannot be cast to allOf type #{self}")
+          end
+        end
       end
     end
   end

data/lib/json_model/type_spec/composition/any_of.rb

@@ -9,6 +9,25 @@ module JsonModel
         def initialize(*types, **options)
           super(:anyOf, *types, **options)
         end
+
+        # @param [::Object] json
+        # @return [::Object]
+        def cast(json)
+          if json.nil?
+            return nil
+          end
+
+          type = @types.detect do |type|
+            type.cast(json)
+          rescue StandardError
+            false
+          end
+          if type.nil?
+            raise(Errors::TypeError, "No matching type found in AnyOf for value: #{json.inspect}")
+          else
+            type.cast(json)
+          end
+        end
       end
     end
   end

data/lib/json_model/type_spec/composition/one_of.rb

@@ -9,6 +9,29 @@ module JsonModel
         def initialize(*types, **options)
           super(:oneOf, *types, **options)
         end
+
+        # @param [::Object] json
+        # @return [::Object]
+        def cast(json)
+          if json.nil?
+            return nil
+          end
+
+          types = @types.select do |type|
+            type.cast(json)
+          rescue StandardError
+            false
+          end
+
+          case types.size
+          when 0
+            raise(Errors::TypeError, "No matching type found in OneOf for value: #{json.inspect}")
+          when 1
+            types.first.cast(json)
+          else
+            raise(Errors::TypeError, "Multiple matching types found in OneOf for value: #{json.inspect}")
+          end
+        end
       end
     end
   end

data/lib/json_model/type_spec/composition.rb

@@ -23,6 +23,12 @@ module JsonModel
       def referenced_schemas
         @types.flat_map(&:referenced_schemas)
       end
+
+      # @param [::Object] json
+      # @return [::Object]
+      def cast(json)
+        raise(NotImplementedError)
+      end
     end
   end
 end

data/lib/json_model/type_spec/object.rb

@@ -19,6 +19,12 @@ module JsonModel
       def referenced_schemas
         [@type]
       end
+
+      # @param [::Object] json
+      # @return [::Object]
+      def cast(json)
+        @type.new(**json)
+      end
     end
   end
 end

data/lib/json_model/type_spec/primitive/boolean.rb

@@ -5,7 +5,7 @@ module JsonModel
     class Primitive
       class Boolean < Primitive
         def initialize
-          super('boolean')
+          super(types: [TrueClass, FalseClass], schema_type: 'boolean')
         end
       end
     end

data/lib/json_model/type_spec/primitive/integer.rb

@@ -6,7 +6,7 @@ module JsonModel
       class Integer < Numeric
         # @param [Hash] options
         def initialize(**options)
-          super('integer', **options)
+          super(types: [::Integer], schema_type: 'integer', **options)
         end
 
         # @param [Symbol] name

data/lib/json_model/type_spec/primitive/null.rb

@@ -5,7 +5,7 @@ module JsonModel
     class Primitive
       class Null < Primitive
         def initialize
-          super('null')
+          super(types: [NilClass], schema_type: 'null')
         end
       end
     end

data/lib/json_model/type_spec/primitive/number.rb

@@ -6,7 +6,7 @@ module JsonModel
       class Number < Numeric
         # @param [Hash] options
         def initialize(**options)
-          super('number', **options)
+          super(types: [Float], schema_type: 'number', **options)
         end
       end
     end

data/lib/json_model/type_spec/primitive/numeric.rb

@@ -4,21 +4,23 @@ module JsonModel
   class TypeSpec
     class Primitive
       class Numeric < Primitive
-        # @param [String] type
+        # @param [::Array<Class>] types
+        # @param [String] schema_type
         # @param [Integer, nil] multiple_of
         # @param [Integer, nil] minimum
         # @param [Integer, nil] maximum
         # @param [Integer, nil] exclusive_minimum
         # @param [Integer, nil] exclusive_maximum
         def initialize(
-          type,
+          types:,
+          schema_type:,
           multiple_of: nil,
           minimum: nil,
           maximum: nil,
           exclusive_minimum: nil,
           exclusive_maximum: nil
         )
-          super(type)
+          super(types: types, schema_type: schema_type)
           @multiple_of = multiple_of
           @minimum = minimum
           @maximum = maximum

data/lib/json_model/type_spec/primitive/string.rb

@@ -82,7 +82,7 @@ module JsonModel
         # @param [Regexp, nil] pattern
         # @param [String, nil] format
         def initialize(min_length: nil, max_length: nil, pattern: nil, format: nil)
-          super('string')
+          super(types: [::String], schema_type: 'string')
 
           @min_length = min_length
           @max_length = max_length
@@ -126,6 +126,8 @@ module JsonModel
 
         private
 
+        # @param [Class] klass
+        # @param [Symbol] name
         def register_format_validation(klass, name)
           if @format.nil?
             return

data/lib/json_model/type_spec/primitive.rb

@@ -3,16 +3,30 @@
 module JsonModel
   class TypeSpec
     class Primitive < TypeSpec
-      # @param [String] type
-      def initialize(type)
+      # @param [::Array<Class>] types
+      # @param [String] schema_type
+      def initialize(types:, schema_type:)
         super()
-        @type = type
+        @types = types
+        @schema_type = schema_type
       end
 
       # @param [Hash] _options
       # @return [Hash]
       def as_schema(**_options)
-        { type: @type }
+        { type: @schema_type }
+      end
+
+      # @param [::Object] json
+      # @return [::Object]
+      def cast(json)
+        if json.nil?
+          nil
+        elsif @types.any? { |type| json.is_a?(type) }
+          json
+        else
+          raise(Errors::TypeError, "Expected #{@type}, got #{json.class} (#{json.inspect})")
+        end
       end
     end
   end

data/lib/json_model/type_spec.rb

@@ -23,6 +23,12 @@ module JsonModel
       []
     end
 
+    # @param [::Object] json
+    # @return [::Object]
+    def cast(json)
+      json
+    end
+
     class << self
       # @param [Object] type
       # @param [Hash] options

data/lib/json_model/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module JsonModel
-  VERSION = '0.1.1'
+  VERSION = '0.1.2'
 end

data/spec/examples/file_system_spec.rb

@@ -0,0 +1,170 @@
+# frozen_string_literal: true
+
+require('spec_helper')
+
+RSpec.describe('File system schema') do
+  before do
+    stub_const(
+      'DiskDevice',
+      Class.new do
+        include(JsonModel::Schema)
+
+        property(:type, type: T::Enum['disk'])
+        property(:device, type: String, pattern: %r{\A/dev/[^/]+(/[^/]+)*\z})
+      end,
+    )
+
+    stub_const(
+      'DiskUuid',
+      Class.new do
+        include(JsonModel::Schema)
+
+        property(:type, type: T::Enum['disk'])
+        property(
+          :label,
+          type: String,
+          pattern: /\A[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}\z/,
+        )
+      end,
+    )
+
+    stub_const(
+      'Nfs',
+      Class.new do
+        include(JsonModel::Schema)
+
+        property(:type, type: T::Enum['nfs'])
+        property(:remote_path, type: String, pattern: %r{\A(/[^/]+)+\z}, as: :remotePath)
+        property(:server, type: String, format: :ipv4)
+      end,
+    )
+
+    stub_const(
+      'Tmpfs',
+      Class.new do
+        include(JsonModel::Schema)
+
+        property(:type, type: T::Enum['tmpfs'])
+        property(:size_in_mb, type: Integer, minimum: 16, maximum: 512, as: :sizeInMB)
+      end,
+    )
+
+    stub_const(
+      'Fstab',
+      Class.new do
+        include(JsonModel::Schema)
+
+        description('JSON Schema for an fstab entry')
+        property(:storage, type: T::OneOf[DiskDevice, DiskUuid, Nfs, Tmpfs], ref_mode: JsonModel::RefMode::LOCAL)
+        property(:fstype, type: T::Enum['ext3', 'ext4', 'btrfs'], optional: true)
+        property(:options, type: T::Array[String], min_items: 1, unique_items: true, optional: true)
+        property(:readonly, type: T::Boolean, optional: true)
+      end,
+    )
+  end
+
+  it('renders the schema') do
+    expect(Fstab.as_schema)
+      .to(
+        eq(
+          {
+            description: 'JSON Schema for an fstab entry',
+            type: 'object',
+            required: %i(storage),
+            properties: {
+              storage: {
+                oneOf: [
+                  { '$ref': '#/$defs/DiskDevice' },
+                  { '$ref': '#/$defs/DiskUuid' },
+                  { '$ref': '#/$defs/Nfs' },
+                  { '$ref': '#/$defs/Tmpfs' },
+                ],
+              },
+              fstype: {
+                enum: %w(ext3 ext4 btrfs),
+              },
+              options: {
+                type: 'array',
+                minItems: 1,
+                items: {
+                  type: 'string',
+                },
+                uniqueItems: true,
+              },
+              readonly: {
+                type: 'boolean',
+              },
+            },
+            additionalProperties: false,
+            '$defs': {
+              DiskDevice: {
+                properties: {
+                  type: {
+                    enum: ['disk'],
+                  },
+                  device: {
+                    type: 'string',
+                    pattern: '\\A/dev/[^/]+(/[^/]+)*\\z',
+                  },
+                },
+                required: %i(device type),
+                additionalProperties: false,
+                type: 'object',
+              },
+              DiskUuid: {
+                properties: {
+                  type: { enum: ['disk'] },
+                  label: {
+                    type: 'string',
+                    pattern: '\\A[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}\\z',
+                  },
+                },
+                required: %i(label type),
+                additionalProperties: false,
+                type: 'object',
+              },
+              Nfs: {
+                properties: {
+                  type: { enum: ['nfs'] },
+                  remotePath: {
+                    type: 'string',
+                    pattern: '\\A(/[^/]+)+\\z',
+                  },
+                  server: {
+                    type: 'string',
+                    format: 'ipv4',
+                  },
+                },
+                required: %i(remotePath server type),
+                additionalProperties: false,
+                type: 'object',
+              },
+              Tmpfs: {
+                properties: {
+                  type: { enum: ['tmpfs'] },
+                  sizeInMB: { type: 'integer', minimum: 16, maximum: 512 },
+                },
+                required: %i(sizeInMB type),
+                additionalProperties: false,
+                type: 'object',
+              },
+            },
+          },
+        ),
+      )
+  end
+
+  it('can instantiate a model') do
+    instance = Fstab.new(
+      storage: { device: '/dev/sda1', type: 'disk' },
+      fstype: 'ext4',
+      options: %w(rw noatime),
+    )
+
+    expect(instance.storage).to(be_a(DiskDevice))
+    expect(instance.storage.device).to(eq('/dev/sda1'))
+    expect(instance.fstype).to(eq('ext4'))
+    expect(instance.options).to(eq(%w(rw noatime)))
+    expect(instance.readonly).to(be_nil)
+  end
+end

data/spec/examples/user_spec.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+require('spec_helper')
+
+RSpec.describe('User schema') do
+  before do
+    address_class = Class.new do
+      include(JsonModel::Schema)
+
+      def self.name
+        'Address'
+      end
+
+      property(:street, type: String)
+      property(:city, type: String)
+      property(:state, type: String, optional: true)
+      property(:postal_code, type: String, pattern: /\A\d{5}(-\d{4})?\z/, optional: true)
+      property(:country, type: String, default: 'USA')
+    end
+
+    stub_const('Address', address_class)
+
+    user_class = Class.new do
+      include(JsonModel::Schema)
+
+      def self.name
+        'User'
+      end
+
+      property(:name, type: String)
+      property(:email, type: String, format: :email)
+      property(:age, type: Integer, minimum: 0, maximum: 120, optional: true)
+      property(:active, type: T::Boolean, default: true, optional: true)
+      property(:addresses, type: T::Array[Address], ref_mode: JsonModel::RefMode::LOCAL)
+      property(:tags, type: T::Array[String], optional: true)
+    end
+
+    stub_const('User', user_class)
+  end
+
+  it('renders the schema') do
+    expect(User.as_schema)
+      .to(
+        eq(
+          {
+            type: 'object',
+            properties: {
+              name: { type: 'string' },
+              email: { type: 'string', format: 'email' },
+              age: { type: 'integer', minimum: 0, maximum: 120 },
+              active: { type: 'boolean', default: true },
+              addresses: {
+                type: 'array',
+                items: { '$ref': '#/$defs/Address' },
+              },
+              tags: { type: 'array', items: { type: 'string' } },
+            },
+            additionalProperties: false,
+            required: %i(addresses email name),
+            '$defs': {
+              Address: {
+                type: 'object',
+                properties: {
+                  city: { type: 'string' },
+                  country: { type: 'string', default: 'USA' },
+                  postal_code: { type: 'string', pattern: '\A\d{5}(-\d{4})?\z' },
+                  state: { type: 'string' },
+                  street: { type: 'string' },
+                },
+                required: %i(city country street),
+                additionalProperties: false,
+              },
+            },
+          },
+        ),
+      )
+  end
+
+  it('can instantiate a model') do
+    user = User.new(name: 'Foo', email: 'foo@example.com', addresses: [{ street: '123 Main St', city: 'Anytown' }])
+
+    expect(user.name).to(eq('Foo'))
+    expect(user.email).to(eq('foo@example.com'))
+    expect(user.active).to(eq(true))
+    expect(user.age).to(be_nil)
+    expect(user.addresses.first.street).to(eq('123 Main St'))
+    expect(user.addresses.first.country).to(eq('USA'))
+    expect(user.addresses.first.postal_code).to(be_nil)
+    expect(user.addresses.first.state).to(be_nil)
+    expect(user.addresses.first.city).to(eq('Anytown'))
+  end
+end

data/spec/schema_meta_spec.rb

@@ -56,6 +56,26 @@ RSpec.describe(JsonModel::SchemaMeta) do
     end
   end
 
+  describe('.description') do
+    let(:klass) do
+      Class.new do
+        include(JsonModel::SchemaMeta)
+      end
+    end
+
+    it('is nil by default') do
+      expect(klass.description)
+        .to(be_nil)
+    end
+
+    it('can be changed') do
+      klass.description('This is a test description.')
+
+      expect(klass.description)
+        .to(eq('This is a test description.'))
+    end
+  end
+
   describe('.additional_properties') do
     let(:klass) do
       Class.new do
@@ -63,9 +83,9 @@ RSpec.describe(JsonModel::SchemaMeta) do
       end
     end
 
-    it('is missing by default') do
+    it('is false by default') do
       expect(klass.meta_attributes)
-        .to(eq({}))
+        .to(eq({ additionalProperties: false }))
     end
 
     it('can be changed') do

data/spec/schema_spec.rb

@@ -72,7 +72,7 @@ RSpec.describe(JsonModel::Schema) do
 
     it('returns an empty schema') do
       expect(klass.as_schema)
-        .to(eq({ type: 'object' }))
+        .to(eq({ type: 'object', additionalProperties: false }))
     end
 
     it('includes the schema id') do
@@ -84,6 +84,7 @@ RSpec.describe(JsonModel::Schema) do
             {
               '$id': 'https://example.com/schemas/example.json',
               type: 'object',
+              additionalProperties: false,
             },
           ),
         )
@@ -116,6 +117,7 @@ RSpec.describe(JsonModel::Schema) do
                 foo: { type: 'string' },
               },
               required: %i(bam baz foo),
+              additionalProperties: false,
             },
           ),
         )
@@ -176,13 +178,16 @@ RSpec.describe(JsonModel::Schema) do
                   type: 'object',
                   properties: { foo: { type: 'string' } },
                   required: %i(foo),
+                  additionalProperties: false,
                 },
               },
+              additionalProperties: false,
               '$defs': {
                 Bar: {
                   type: 'object',
                   properties: { bar: { type: 'string' } },
                   required: %i(bar),
+                  additionalProperties: false,
                 },
               },
               required: %i(bam bar foo),
@@ -209,6 +214,7 @@ RSpec.describe(JsonModel::Schema) do
                 '$id': 'https://example.com/schemas/child.json',
                 '$ref': 'https://example.com/schemas/example.json',
                 type: 'object',
+                additionalProperties: false,
               },
             ),
           )

data/spec/type_spec/composition/all_of_spec.rb

@@ -17,4 +17,41 @@ RSpec.describe(JsonModel::TypeSpec::Composition::AllOf) do
         )
     end
   end
+
+  describe('#cast') do
+    let(:foo) do
+      Class.new do
+        include(JsonModel::Schema)
+
+        additional_properties(true)
+        property(:foo, type: String)
+      end
+    end
+
+    let(:bar) do
+      Class.new do
+        include(JsonModel::Schema)
+
+        additional_properties(true)
+        property(:bar, type: String)
+      end
+    end
+
+    subject { described_class.new(JsonModel::TypeSpec::Object.new(foo), JsonModel::TypeSpec::Object.new(bar)) }
+
+    it('raises if one of the types fails') do
+      expect { subject.cast({ foo: 'foo' }) }
+        .to(raise_error(JsonModel::Errors::TypeError))
+    end
+
+    it('returns the value if all types pass') do
+      foo_instance, bar_instance = subject.cast({ foo: 'foo', bar: 'bar' })
+
+      expect(foo_instance).to(be_instance_of(foo))
+      expect(foo_instance.foo).to(eq('foo'))
+
+      expect(bar_instance).to(be_instance_of(bar))
+      expect(bar_instance.bar).to(eq('bar'))
+    end
+  end
 end

data/spec/type_spec/composition/any_of_spec.rb

@@ -17,4 +17,38 @@ RSpec.describe(JsonModel::TypeSpec::Composition::AnyOf) do
         )
     end
   end
+
+  describe('#cast') do
+    let(:foo) do
+      Class.new do
+        include(JsonModel::Schema)
+
+        additional_properties(true)
+        property(:foo, type: String)
+      end
+    end
+
+    let(:bar) do
+      Class.new do
+        include(JsonModel::Schema)
+
+        additional_properties(true)
+        property(:bar, type: String)
+      end
+    end
+
+    subject { described_class.new(JsonModel::TypeSpec::Object.new(foo), JsonModel::TypeSpec::Object.new(bar)) }
+
+    it('raises if all of the types fail') do
+      expect { subject.cast({ bam: 'bam' }) }
+        .to(raise_error(JsonModel::Errors::TypeError))
+    end
+
+    it('returns the value if any type passes') do
+      foo_instance = subject.cast({ foo: 'foo' })
+
+      expect(foo_instance).to(be_instance_of(foo))
+      expect(foo_instance.foo).to(eq('foo'))
+    end
+  end
 end

data/spec/type_spec/composition/one_of_spec.rb

@@ -17,4 +17,43 @@ RSpec.describe(JsonModel::TypeSpec::Composition::OneOf) do
         )
     end
   end
+
+  describe('#cast') do
+    let(:foo) do
+      Class.new do
+        include(JsonModel::Schema)
+
+        additional_properties(true)
+        property(:foo, type: String)
+      end
+    end
+
+    let(:bar) do
+      Class.new do
+        include(JsonModel::Schema)
+
+        additional_properties(true)
+        property(:bar, type: String)
+      end
+    end
+
+    subject { described_class.new(JsonModel::TypeSpec::Object.new(foo), JsonModel::TypeSpec::Object.new(bar)) }
+
+    it('raises if all of the types fail') do
+      expect { subject.cast({ bam: 'bam' }) }
+        .to(raise_error(JsonModel::Errors::TypeError))
+    end
+
+    it('raises if more than one type passes') do
+      expect { subject.cast({ foo: 'foo', bar: 'bar' }) }
+        .to(raise_error(JsonModel::Errors::TypeError))
+    end
+
+    it('returns the value if one type passes') do
+      foo_instance = subject.cast({ foo: 'foo' })
+
+      expect(foo_instance).to(be_instance_of(foo))
+      expect(foo_instance.foo).to(eq('foo'))
+    end
+  end
 end

data/spec/type_spec/composition_spec.rb

@@ -27,6 +27,7 @@ RSpec.describe(JsonModel::TypeSpec::Composition) do
                   type: 'object',
                   properties: { foo: { type: 'string' } },
                   required: %i(foo),
+                  additionalProperties: false,
                 },
               ],
             },

data/spec/type_spec/primitive/numeric_spec.rb

@@ -5,27 +5,27 @@ require('spec_helper')
 RSpec.describe(JsonModel::TypeSpec::Primitive::Numeric) do
   describe('#as_schema') do
     it('includes the multipleOf attribute') do
-      expect(described_class.new('number', multiple_of: 5).as_schema)
+      expect(described_class.new(types: [Integer, Float], schema_type: 'number', multiple_of: 5).as_schema)
         .to(eq({ type: 'number', multipleOf: 5 }))
     end
 
     it('includes the minimum attribute') do
-      expect(described_class.new('number', minimum: 5).as_schema)
+      expect(described_class.new(types: [Integer, Float], schema_type: 'number', minimum: 5).as_schema)
         .to(eq({ type: 'number', minimum: 5 }))
     end
 
     it('includes the maximum attribute') do
-      expect(described_class.new('number', maximum: 5).as_schema)
+      expect(described_class.new(types: [Integer, Float], schema_type: 'number', maximum: 5).as_schema)
         .to(eq({ type: 'number', maximum: 5 }))
     end
 
     it('includes the exclusiveMinimum attribute') do
-      expect(described_class.new('number', exclusive_minimum: 5).as_schema)
+      expect(described_class.new(types: [Integer, Float], schema_type: 'number', exclusive_minimum: 5).as_schema)
         .to(eq({ type: 'number', exclusiveMinimum: 5 }))
     end
 
     it('includes the exclusiveMaximum attribute') do
-      expect(described_class.new('number', exclusive_maximum: 5).as_schema)
+      expect(described_class.new(types: [Integer, Float], schema_type: 'number', exclusive_maximum: 5).as_schema)
         .to(eq({ type: 'number', exclusiveMaximum: 5 }))
     end
   end
@@ -46,7 +46,7 @@ RSpec.describe(JsonModel::TypeSpec::Primitive::Numeric) do
     context('for multiple of') do
       before do
         described_class
-          .new('number', multiple_of: 5)
+          .new(types: [Integer, Float], schema_type: 'number', multiple_of: 5)
           .register_validations(:foo, klass)
       end
 
@@ -72,7 +72,7 @@ RSpec.describe(JsonModel::TypeSpec::Primitive::Numeric) do
     context('for minimum') do
       before do
         described_class
-          .new('number', minimum: 5)
+          .new(types: [Integer, Float], schema_type: 'number', minimum: 5)
           .register_validations(:foo, klass)
       end
 
@@ -98,7 +98,7 @@ RSpec.describe(JsonModel::TypeSpec::Primitive::Numeric) do
     context('for maximum') do
       before do
         described_class
-          .new('number', maximum: 5)
+          .new(types: [Integer, Float], schema_type: 'number', maximum: 5)
           .register_validations(:foo, klass)
       end
 
@@ -124,7 +124,7 @@ RSpec.describe(JsonModel::TypeSpec::Primitive::Numeric) do
     context('for exclusive_minimum') do
       before do
         described_class
-          .new('number', exclusive_minimum: 5)
+          .new(types: [Integer, Float], schema_type: 'number', exclusive_minimum: 5)
           .register_validations(:foo, klass)
       end
 
@@ -150,7 +150,7 @@ RSpec.describe(JsonModel::TypeSpec::Primitive::Numeric) do
     context('for exclusive_maximum') do
       before do
         described_class
-          .new('number', exclusive_maximum: 5)
+          .new(types: [Integer, Float], schema_type: 'number', exclusive_maximum: 5)
           .register_validations(:foo, klass)
       end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: json_model_rb
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - Paul Gillesberger
@@ -108,6 +108,7 @@ files:
 - lib/json_model/errors.rb
 - lib/json_model/errors/error.rb
 - lib/json_model/errors/invalid_ref_mode_error.rb
+- lib/json_model/errors/type_error.rb
 - lib/json_model/errors/unknown_attribute_error.rb
 - lib/json_model/properties.rb
 - lib/json_model/property.rb
@@ -138,6 +139,8 @@ files:
 - lib/json_model/types/one_of.rb
 - lib/json_model/version.rb
 - spec/config_spec.rb
+- spec/examples/file_system_spec.rb
+- spec/examples/user_spec.rb
 - spec/json_model_spec.rb
 - spec/properties_spec.rb
 - spec/property_spec.rb