json_model_rb 0.1.13 → 0.1.15

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e4f530abe8264be24ec3b62c627bbab78fe3d25ace6bbd03a9360d7bbac688f2
-  data.tar.gz: e1997308062e1cd0b3af670b381bd461324f0c29e49457534cd1196048f57c47
+  metadata.gz: ae63a0cef5ca421b32a3a103aeaaa8c61cfe9a1edd7871567e8c8f5905678f5d
+  data.tar.gz: b51047217b904c7194deb9c21bcd66a175ae18779360d68a78db5efa3190d12a
 SHA512:
-  metadata.gz: aa7626727be77b8da34aa0775f2c8ba3f1f2e636dfca50b83224e51c92e7d78c70079a2732fb0ee17ded82f295d1d2f0654e274b94ceff224b55c36aa99bff88
-  data.tar.gz: 8bcd5c1fee253effded868ff5466f00969eebd6e50ae6c5ace3dce2bb5befc6ea6be3730bfd3ca9806bf5380267591df23dc679d97bb2751f227a9ef819669bc
+  metadata.gz: 05f4f40b76349054936c5df92514615c3a86ebb9eaa54d5e9105c59dc33d836fc4718f98d1590a34d7569ed86e14a292ee70a2f7e17b241fea337f81074e4d82
+  data.tar.gz: b9b97ae062116a998eb894e8a98d486dc8ffa141d2a49c5b4755afe41358b0ff4b8aed7a8283bbe744107980a3206a858b2de6d16deacdbe01102bf5a4aed300

data/README.md

@@ -99,7 +99,7 @@ class Product
   # Properties
   property :id, type: String
   property :name, type: String
-  property :price, type: Float, minimum: 0
+  property :price, type: T::Float[minimum: 0]
   property :available, type: T::Boolean, default: true, optional: true
 end
 ```
@@ -124,30 +124,28 @@ class StringExample
   property :simple_string, type: String
 
   # String with length constraints
-  property :username, type: String, 
-    min_length: 3,
-    max_length: 20
+  property :username, type: T::String[min_length: 3, max_length: 20]
 
   # String with pattern (regex)
-  property :product_code, type: String, pattern: /\A[A-Z]{3}-\d{4}\z/
+  property :product_code, type: T::String[pattern: /\A[A-Z]{3}-\d{4}\z/]
 
   # String with format
-  property :email, type: String, format: :email
-  property :uri, type: String, format: :uri
-  property :hostname, type: String, format: :hostname
-  property :ipv4, type: String, format: :ipv4
-  property :ipv6, type: String, format: :ipv6
-  property :uuid, type: String, format: :uuid
-  property :date, type: String, format: :date
-  property :time, type: String, format: :time
-  property :datetime, type: String, format: :date_time
-  property :duration, type: String, format: :duration
+  property :email, type: T::String[format: :email]
+  property :uri, type: T::String[format: :uri]
+  property :hostname, type: T::String[format: :hostname]
+  property :ipv4, type: T::String[format: :ipv4]
+  property :ipv6, type: T::String[format: :ipv6]
+  property :uuid, type: T::String[format: :uuid]
+  property :date, type: T::String[format: :date]
+  property :time, type: T::String[format: :time]
+  property :datetime, type: T::String[format: :date_time]
+  property :duration, type: T::String[format: :duration]
   
   # String with enum
-  property :status, type: String, enum: ["draft", "published", "archived"]
+  property :status, T::Enum["draft", "published", "archived"]
   
   # String with const
-  property :api_version, type: String, const: "v1"
+  property :api_version, T::Const["v1"]
   
   # Optional string
   property :nickname, type: String, optional: true
@@ -244,19 +242,19 @@ class NumericExample
   property :count, type: Integer
 
   # Integer with range
-  property :port, type: Integer, minimum: 1024, maximum: 65535
+  property :port, type: T::Integer[minimum: 1024, maximum: 65535]
 
   # Integer with exclusive bounds
-  property :positive_int, type: Integer, exclusive_minimum: 0
+  property :positive_int, type: T::Integer[exclusive_minimum: 0]
 
   # Number (float/double)
-  property :price, type: Float, minimum: 0
+  property :price, type: T::Number[minimum: 0]
 
   # Number with multiple_of
-  property :quantity, type: Integer, multiple_of: 10
+  property :quantity, type: T::Integer[multiple_of: 10]
 
   # Number with precision
-  property :temperature, type: Float, minimum: -273.15, maximum: 1000.0
+  property :temperature, type: T::Number[minimum: -273.15, maximum: 1000.0]
   
   # Optional number
   property :discount, type: Float, optional: true
@@ -361,7 +359,7 @@ class ArrayExample
   property :tags, type: T::Array[String]
 
   # Array with constraints
-  property :numbers, type: T::Array[Integer], min_items: 1, max_items: 10, unique_items: true
+  property :numbers, type: T::Array[Integer, min_items: 1, max_items: 10, unique_items: true]
 end
 
 # Generate the JSON Schema
@@ -410,15 +408,15 @@ class PersonBase
   include JsonModel::Schema
 
   property :name, type: String
-  property :age, type: Integer, minimum: 0, optional: true
+  property :age, type: T::Integer[minimum: 0], optional: true
 end
 
 class EmployeeDetails
   include JsonModel::Schema
 
-  property :employee_id, type: String, pattern: /\AE-\d{4}\z/
+  property :employee_id, type: T::String[pattern: /\AE-\d{4}\z/]
   property :department, type: String
-  property :salary, type: Float, minimum: 0, optional: true
+  property :salary, type: T::Number[minimum: 0], optional: true
 end
 
 class Employee
@@ -504,7 +502,7 @@ end
 class PhoneContact
   include JsonModel::Schema
 
-  property :phone, type: String, pattern: /\A\+?[1-9]\\d{1,14}\z/
+  property :phone, type: T::String[pattern: /\A\+?[1-9]\\d{1,14}\z/]
 end
 
 class AddressContact
@@ -596,24 +594,24 @@ Use `T::OneOf` when a value must validate against exactly one schema (exclusive
 class CreditCardPayment
   include JsonModel::Schema
 
-  property :payment_type, type: String, const: "credit_card"
-  property :card_number, type: String, pattern: /\A\d{16}\z/
-  property :cvv, type: String, pattern: /\A\d{3,4}\z/
-  property :expiry, type: String, pattern: /\A\d{2}\/\d{2}\z/
+  property :payment_type, T::Const["credit_card"]
+  property :card_number, type: T::String[pattern: /\A\d{16}\z/]
+  property :cvv, type: T::String[pattern: /\A\d{3,4}\z/]
+  property :expiry, type: T::String[pattern: /\A\d{2}\/\d{2}\z/]
 end
 
 class PayPalPayment
   include JsonModel::Schema
 
-  property :payment_type, type: String, const: "paypal"
-  property :paypal_email, type: String, format: :email
+  property :payment_type, T::Const["paypal"]
+  property :paypal_email, type: T::String[format: :email]
 end
 
 class BankTransferPayment
   include JsonModel::Schema
 
-  property :payment_type, type: String, const: "bank_transfer"
-  property :iban, type: String, pattern: "^[A-Z]{2}\\d{2}[A-Z0-9]+$"
+  property :payment_type, type: T::Const["bank_transfer"]
+  property :iban, type: T::String[pattern: "^[A-Z]{2}\\d{2}[A-Z0-9]+$"]
   property :swift, type: String, optional: true
 end
 
@@ -623,7 +621,7 @@ class PaymentMethod
   title "Payment Method"
   description "Must specify exactly one payment method"
 
-  property :payment, type: T::OneOf[CreditCardPayment, PayPalPayment, BankTransferPayment]
+  property :payment, type: T::OneOf[CreditCardPayment, PayPalPayment, BankTransferPayment], discriminator: :payment_type
 end
 
 # Generate the JSON Schema

data/lib/json_model/properties.rb

@@ -30,16 +30,16 @@ module JsonModel
       def invert_alias(name)
         aliased_properties[name]&.name || superclass&.invert_alias(name)
       rescue NoMethodError
+        nil
       end
 
       # @param [Symbol] name
       # @param [Object, Class] type
       # @param [Hash] options
       def property(name, type:, **options)
-        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) }
+        resolved_type = TypeSpec.resolve(type)
+        add_property(name, type: resolved_type, **options)
+        descendants.each { |subclass| subclass.add_property(name, type: resolved_type, **options) }
       end
 
       protected

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

@@ -17,7 +17,7 @@ module JsonModel
             return nil
           end
 
-          @types.map do |type|
+          types_for(json).map do |type|
             type.cast(json)
           rescue StandardError
             raise(Errors::TypeError, "Value #{json.inspect} cannot be cast to allOf type #{self}")

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

@@ -17,7 +17,7 @@ module JsonModel
             return nil
           end
 
-          type = @types.detect do |type|
+          type = types_for(json).detect do |type|
             type.cast(json)
           rescue StandardError
             false

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

@@ -17,7 +17,7 @@ module JsonModel
             return nil
           end
 
-          types = @types.select do |type|
+          types = types_for(json).select do |type|
             type.cast(json)
           rescue StandardError
             false

data/lib/json_model/type_spec/composition.rb

@@ -3,25 +3,28 @@
 module JsonModel
   class TypeSpec
     class Composition < TypeSpec
+      attr_reader(:types, :modifier, :discriminator)
+
       # @param [Symbol] modifier
-      # @param [TypeSpec] types
-      def initialize(modifier, *types)
+      # @param [::Array<TypeSpec>] types
+      def initialize(modifier, *types, discriminator: nil)
         super()
         @types = types
         @modifier = modifier
+        @discriminator = discriminator
       end
 
       # @param [Hash] options
       # @return [Hash]
       def as_schema(**options)
         {
-          @modifier => @types.map { |type| type.as_schema(**options) },
+          modifier => types.map { |type| type.as_schema(**options) },
         }
       end
 
       # @return [Array<TypeSpec>]
       def referenced_schemas
-        @types.flat_map(&:referenced_schemas)
+        types.flat_map(&:referenced_schemas)
       end
 
       # @param [::Object] json
@@ -29,6 +32,44 @@ module JsonModel
       def cast(json)
         raise(NotImplementedError)
       end
+
+      protected
+
+      # @return [Hash, nil]
+      def type_map
+        if discriminator.nil?
+          return nil
+        end
+
+        @type_map ||= types.each_with_object({}) do |type, hash|
+          if !type.is_a?(Object)
+            raise('Discriminator property can only be used with Object types')
+          end
+
+          discriminator_property = type.type.properties[discriminator]
+          discriminator_values = if discriminator_property&.type.is_a?(Const)
+                                   [discriminator_property.type.value]
+                                 elsif discriminator_property&.type.is_a?(Enum)
+                                   discriminator_property.type.values
+                                 else
+                                   raise('Discriminator property must be of type Const or Enum')
+                                 end
+          discriminator_values.each do |value|
+            hash[value] ||= []
+            hash[value] << type
+          end
+        end
+      end
+
+      # @param [::Object] json
+      # @return [::Array<TypeSpec>]
+      def types_for(json)
+        if type_map.nil?
+          types
+        else
+          type_map[json[discriminator]]
+        end
+      end
     end
   end
 end

data/lib/json_model/type_spec/const.rb

@@ -3,6 +3,8 @@
 module JsonModel
   class TypeSpec
     class Const < TypeSpec
+      attr_reader(:value)
+
       # @param [String] value
       def initialize(value)
         super()
@@ -17,7 +19,7 @@ module JsonModel
       # @return [Hash]
       def as_schema(**_options)
         {
-          const: @value,
+          const: value,
         }.compact
       end
 
@@ -26,7 +28,7 @@ module JsonModel
       def register_validations(name, klass)
         super
 
-        klass.validates(name, inclusion: { in: @value }, allow_nil: true)
+        klass.validates(name, inclusion: { in: value }, allow_nil: true)
       end
     end
   end

data/lib/json_model/type_spec/enum.rb

@@ -3,6 +3,8 @@
 module JsonModel
   class TypeSpec
     class Enum < TypeSpec
+      attr_reader(:values)
+
       # @param [Array<Object, nil>] values
       def initialize(*values)
         super()
@@ -17,7 +19,7 @@ module JsonModel
       # @return [Hash]
       def as_schema(**_options)
         {
-          enum: @values,
+          enum: values,
         }.compact
       end
 
@@ -26,7 +28,7 @@ module JsonModel
       def register_validations(name, klass)
         super
 
-        klass.validates(name, inclusion: { in: @values }, allow_nil: true)
+        klass.validates(name, inclusion: { in: values }, allow_nil: true)
       end
     end
   end

data/lib/json_model/type_spec/object.rb

@@ -3,6 +3,8 @@
 module JsonModel
   class TypeSpec
     class Object < TypeSpec
+      attr_reader(:type)
+
       # @param [Schema] type
       def initialize(type)
         super()
@@ -12,18 +14,18 @@ module JsonModel
       # @param [Hash] options
       # @return [Hash]
       def as_schema(**options)
-        @type.as_schema(**options)
+        type.as_schema(**options)
       end
 
       # @return [Array<TypeSpec>]
       def referenced_schemas
-        [@type]
+        [type]
       end
 
       # @param [::Object] json
       # @return [::Object, nil]
       def cast(json)
-        @type.from_json(**json)
+        type.from_json(**json)
       end
     end
   end

data/lib/json_model/type_spec.rb

@@ -32,39 +32,39 @@ module JsonModel
 
     class << self
       # @param [Object, Class] type
-      # @param [Hash] options
       # @return [TypeSpec]
-      def resolve(type, **options)
+      def resolve(type)
         case type
         when TypeSpec
           type
         when Class
-          resolve_type_from_class(type, **options)
-        when T::AllOf, T::AnyOf, T::Boolean, T::OneOf, T::Array, T::Enum, T::Const
-          type.to_type_spec(**options)
+          resolve_type_from_class(type)
         else
-          raise(ArgumentError, "Unsupported type: #{type}")
+          if type.respond_to?(:to_type_spec)
+            type.to_type_spec
+          else
+            raise(ArgumentError, "Unsupported type: #{type}")
+          end
         end
       end
 
       private
 
       # @param [Object, Class] type
-      # @param [Hash] options
       # @return [TypeSpec]
-      def resolve_type_from_class(type, **options)
+      def resolve_type_from_class(type)
         if type == String
-          Primitive::String.new(**options)
+          Primitive::String.new
         elsif type == Integer
-          Primitive::Integer.new(**options)
+          Primitive::Integer.new
         elsif type == Float
-          Primitive::Number.new(**options)
+          Primitive::Number.new
         elsif [TrueClass, FalseClass].include?(type)
-          Primitive::Boolean.new(**options)
+          Primitive::Boolean.new
         elsif type == NilClass
-          Primitive::Null.new(**options)
+          Primitive::Null.new
         elsif type < Schema
-          TypeSpec::Object.new(type, **options)
+          TypeSpec::Object.new(type)
         else
           raise(ArgumentError, "Unsupported type: #{type}")
         end

data/lib/json_model/types/all_of.rb

@@ -3,23 +3,26 @@
 module T
   class AllOf
     # @param [Array<Class>] types
-    def initialize(*types)
+    # @param [Hash] options
+    def initialize(*types, **options)
       @types = types
+      @options = options
     end
 
     # @return [JsonModel::TypeSpec::Composition::AllOf]
-    def to_type_spec(**options)
+    def to_type_spec
       JsonModel::TypeSpec::Composition::AllOf.new(
         *@types.map { |type| JsonModel::TypeSpec.resolve(type) },
-        **options,
+        **@options,
       )
     end
 
     class << self
       # @param [Array] types
+      # @param [Hash] options
       # @return [AllOf]
-      def [](*types)
-        AllOf.new(*types)
+      def [](*types, **options)
+        AllOf.new(*types, **options)
       end
     end
   end

data/lib/json_model/types/any_of.rb

@@ -3,23 +3,26 @@
 module T
   class AnyOf
     # @param [Array<Class>] types
-    def initialize(*types)
+    # @param [Hash] options
+    def initialize(*types, **options)
       @types = types
+      @options = options
     end
 
     # @return [JsonModel::TypeSpec::Composition::AnyOf]
-    def to_type_spec(**options)
+    def to_type_spec
       JsonModel::TypeSpec::Composition::AnyOf.new(
         *@types.map { |type| JsonModel::TypeSpec.resolve(type) },
-        **options,
+        **@options,
       )
     end
 
     class << self
       # @param [Array] types
+      # @param [Hash] options
       # @return [AnyOf]
-      def [](*types)
-        AnyOf.new(*types)
+      def [](*types, **options)
+        AnyOf.new(*types, **options)
       end
     end
   end

data/lib/json_model/types/array.rb

@@ -3,23 +3,26 @@
 module T
   class Array
     # @param [Class] type
-    def initialize(type)
+    # @param [Hash] options
+    def initialize(type, **options)
       @type = type
+      @options = options
     end
 
     # @return [JsonModel::TypeSpec::Array]
-    def to_type_spec(**options)
+    def to_type_spec
       JsonModel::TypeSpec::Array.new(
         JsonModel::TypeSpec.resolve(@type),
-        **options,
+        **@options,
       )
     end
 
     class << self
       # @param [Class] type
+      # @param [Hash] options
       # @return [Array]
-      def [](type)
-        Array.new(type)
+      def [](type, **options)
+        Array.new(type, **options)
       end
     end
   end

data/lib/json_model/types/boolean.rb

@@ -2,6 +2,6 @@
 
 module T
   Boolean = Class.new do
-    def to_type_spec(**_options) = JsonModel::TypeSpec::Primitive::Boolean.new
+    def to_type_spec = JsonModel::TypeSpec::Primitive::Boolean.new
   end.new
 end

data/lib/json_model/types/const.rb

@@ -8,8 +8,8 @@ module T
     end
 
     # @return [JsonModel::TypeSpec::Const]
-    def to_type_spec(**options)
-      JsonModel::TypeSpec::Const.new(*@value, **options)
+    def to_type_spec
+      JsonModel::TypeSpec::Const.new(*@value)
     end
 
     class << self

data/lib/json_model/types/enum.rb

@@ -8,8 +8,8 @@ module T
     end
 
     # @return [JsonModel::TypeSpec::Enum]
-    def to_type_spec(**options)
-      JsonModel::TypeSpec::Enum.new(*@values, **options)
+    def to_type_spec
+      JsonModel::TypeSpec::Enum.new(*@values)
     end
 
     class << self

data/lib/json_model/types/integer.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module T
+  class Integer
+    # @param [Hash] options
+    def initialize(**options)
+      @options = options
+    end
+
+    # @return [JsonModel::TypeSpec::Composition::Primitive::Integer]
+    def to_type_spec
+      JsonModel::TypeSpec::Primitive::Integer.new(**@options)
+    end
+
+    class << self
+      # @param [Hash] options
+      # @return [T::Integer]
+      def [](**options)
+        Integer.new(**options)
+      end
+    end
+  end
+end

data/lib/json_model/types/null.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module T
+  Null = Class.new do
+    def to_type_spec = JsonModel::TypeSpec::Primitive::Null.new
+  end.new
+end

data/lib/json_model/types/number.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module T
+  class Number
+    # @param [Hash] options
+    def initialize(**options)
+      @options = options
+    end
+
+    # @return [JsonModel::TypeSpec::Composition::Primitive::Number]
+    def to_type_spec
+      JsonModel::TypeSpec::Primitive::Number.new(**@options)
+    end
+
+    class << self
+      # @param [Hash] options
+      # @return [Number]
+      def [](**options)
+        Number.new(**options)
+      end
+    end
+  end
+end

data/lib/json_model/types/one_of.rb

@@ -3,23 +3,26 @@
 module T
   class OneOf
     # @param [Array<Class>] types
-    def initialize(*types)
+    # @param [Hash] options
+    def initialize(*types, **options)
       @types = types
+      @options = options
     end
 
     # @return [JsonModel::TypeSpec::Composition::OneOf]
-    def to_type_spec(**options)
+    def to_type_spec
       JsonModel::TypeSpec::Composition::OneOf.new(
         *@types.map { |type| JsonModel::TypeSpec.resolve(type) },
-        **options,
+        **@options,
       )
     end
 
     class << self
       # @param [Array] types
+      # @param [Hash] options
       # @return [OneOf]
-      def [](*types)
-        OneOf.new(*types)
+      def [](*types, **options)
+        OneOf.new(*types, **options)
       end
     end
   end

data/lib/json_model/types/string.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module T
+  class String
+    # @param [Hash] options
+    def initialize(**options)
+      @options = options
+    end
+
+    # @return [JsonModel::TypeSpec::Composition::Primitive::String]
+    def to_type_spec
+      JsonModel::TypeSpec::Primitive::String.new(**@options)
+    end
+
+    class << self
+      # @param [Hash] options
+      # @return [T::String]
+      def [](**options)
+        String.new(**options)
+      end
+    end
+  end
+end

data/lib/json_model/types.rb

@@ -2,8 +2,12 @@
 
 require_relative('types/all_of')
 require_relative('types/any_of')
-require_relative('types/boolean')
-require_relative('types/one_of')
 require_relative('types/array')
+require_relative('types/boolean')
 require_relative('types/const')
 require_relative('types/enum')
+require_relative('types/integer')
+require_relative('types/null')
+require_relative('types/number')
+require_relative('types/one_of')
+require_relative('types/string')

data/lib/json_model/version.rb

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

data/spec/examples/file_system_spec.rb

@@ -9,8 +9,8 @@ RSpec.describe('File system schema') do
       Class.new do
         include(JsonModel::Schema)
 
-        property(:type, type: T::Enum['disk'])
-        property(:device, type: String, pattern: %r{\A/dev/[^/]+(/[^/]+)*\z})
+        property(:type, type: T::Const['disk'])
+        property(:device, type: T::String[pattern: %r{\A/dev/[^/]+(/[^/]+)*\z}])
       end,
     )
 
@@ -19,11 +19,10 @@ RSpec.describe('File system schema') do
       Class.new do
         include(JsonModel::Schema)
 
-        property(:type, type: T::Enum['disk'])
+        property(:type, type: T::Enum['diskUUID', 'diskuuid'])
         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/,
+          type: T::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,
     )
@@ -33,9 +32,9 @@ RSpec.describe('File system schema') do
       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)
+        property(:type, type: T::Const['nfs'])
+        property(:remote_path, type: T::String[pattern: %r{\A(/[^/]+)+\z}], as: :remotePath)
+        property(:server, type: T::String[format: :ipv4])
       end,
     )
 
@@ -44,8 +43,8 @@ RSpec.describe('File system schema') do
       Class.new do
         include(JsonModel::Schema)
 
-        property(:type, type: T::Enum['tmpfs'])
-        property(:size_in_mb, type: Integer, minimum: 16, maximum: 512, as: :sizeInMB)
+        property(:type, type: T::Const['tmpfs'])
+        property(:size_in_mb, type: T::Integer[minimum: 16, maximum: 512], as: :sizeInMB)
       end,
     )
 
@@ -55,9 +54,13 @@ RSpec.describe('File system schema') 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(
+          :storage,
+          type: T::OneOf[DiskDevice, DiskUuid, Nfs, Tmpfs, discriminator: :type],
+          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(:options, type: T::Array[String, min_items: 1, unique_items: true], optional: true)
         property(:readonly, type: T::Boolean, optional: true)
       end,
     )
@@ -100,7 +103,7 @@ RSpec.describe('File system schema') do
               DiskDevice: {
                 properties: {
                   type: {
-                    enum: ['disk'],
+                    const: 'disk',
                   },
                   device: {
                     type: 'string',
@@ -113,7 +116,7 @@ RSpec.describe('File system schema') do
               },
               DiskUuid: {
                 properties: {
-                  type: { enum: ['disk'] },
+                  type: { enum: %w(diskUUID diskuuid) },
                   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',
@@ -125,7 +128,7 @@ RSpec.describe('File system schema') do
               },
               Nfs: {
                 properties: {
-                  type: { enum: ['nfs'] },
+                  type: { const: 'nfs' },
                   remotePath: {
                     type: 'string',
                     pattern: '\\A(/[^/]+)+\\z',
@@ -141,7 +144,7 @@ RSpec.describe('File system schema') do
               },
               Tmpfs: {
                 properties: {
-                  type: { enum: ['tmpfs'] },
+                  type: { const: 'tmpfs' },
                   sizeInMB: { type: 'integer', minimum: 16, maximum: 512 },
                 },
                 required: %i(sizeInMB type),

data/spec/examples/user_spec.rb

@@ -14,7 +14,7 @@ RSpec.describe('User schema') do
       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(:postal_code, type: T::String[pattern: /\A\d{5}(-\d{4})?\z/], optional: true)
       property(:country, type: String, default: 'USA')
     end
 
@@ -28,8 +28,8 @@ RSpec.describe('User schema') do
       end
 
       property(:name, type: String)
-      property(:email, type: String, format: :email)
-      property(:age, type: Integer, minimum: 0, maximum: 120, optional: true)
+      property(:email, type: T::String[format: :email])
+      property(:age, type: T::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)

data/spec/schema_spec.rb

@@ -44,7 +44,7 @@ RSpec.describe(JsonModel::Schema) do
       Class.new do
         include(JsonModel::Schema)
 
-        property(:foo, type: String, min_length: 3)
+        property(:foo, type: T::String[min_length: 3])
       end
     end
 
@@ -76,7 +76,7 @@ RSpec.describe(JsonModel::Schema) do
 
       stub_const(
         'Bar',
-        Class.new(Foo) {},
+        Class.new(Foo),
       )
     end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: json_model_rb
 version: !ruby/object:Gem::Version
-  version: 0.1.13
+  version: 0.1.15
 platform: ruby
 authors:
 - Paul Gillesberger
@@ -138,7 +138,11 @@ files:
 - lib/json_model/types/boolean.rb
 - lib/json_model/types/const.rb
 - lib/json_model/types/enum.rb
+- lib/json_model/types/integer.rb
+- lib/json_model/types/null.rb
+- lib/json_model/types/number.rb
 - lib/json_model/types/one_of.rb
+- lib/json_model/types/string.rb
 - lib/json_model/version.rb
 - spec/config_spec.rb
 - spec/examples/component_spec.rb