json_model_rb 0.1.14 → 0.1.16

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 55a34992353fa6800b488fba56a9516d78c0b1c256c987ea7f22cb61782477dc
-  data.tar.gz: c3d0b4289612c86e3e7ba805b26209534099503947df12885591decb2942a647
+  metadata.gz: f5c3f4ee507240e543a97f2ef35f1ec1bc998530547c4f841164c86baaf06c88
+  data.tar.gz: 456f3afae37e3a2f5d040f20dabc7c86a3ae534c60ca40fefae2d6b24155e200
 SHA512:
-  metadata.gz: 128cceae1c36a9b9f130013417d2e0131a8b3b673b6cedde600297bb1d1d327fa7cfb91ebecf974af72f05e6efe96849ee2477f3e734b2b5e90ee6b0f2655c09
-  data.tar.gz: bb21f9d7ff5ccedcd7448f148d69ce78502b7f7200d0e6cb90edf5b54d77afae0284a3729c9d4dcba9fbac82253b3a95d957bd1aef56bc8a641453f0971a5283
+  metadata.gz: 6404570b5ae3113f6f067da85b595fe066f866f226a87b381909593da31046f427ed59ccb08f7174986106b58dc47487bca9eeee1b7b4eb1312bb7f6102b6712
+  data.tar.gz: 65a200948801a4238e3780ab24953b7e36a1404c1a4012a21af6e117b2cf24b2609aeb87eaaa36f8fa7d0d8917c9a97e9843dcb3e5976689c99152bc7e855ef1

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
 

data/lib/json_model/config.rb

@@ -39,5 +39,7 @@ module JsonModel
     end
 
     option(:validate_after_instantiation, default: true)
+
+    option(:schema_version)
   end
 end

data/lib/json_model/properties.rb

@@ -37,10 +37,9 @@ module JsonModel
       # @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/schema_meta.rb

@@ -17,12 +17,11 @@ module JsonModel
       def self.inherited(subclass)
         super
         subclass.schema_id(JsonModel.config.schema_id_naming_strategy.call(subclass))
-        subclass.additional_properties(false)
         subclass.meta_attributes[:$ref] = schema_id
       end
 
       schema_id(JsonModel.config.schema_id_naming_strategy.call(self))
-      additional_properties(false)
+      schema_version(JsonModel.config.schema_version)
     end
 
     class_methods do
@@ -71,6 +70,16 @@ module JsonModel
         end
       end
 
+      # @param [Boolean, nil] value
+      # @return [Boolean]
+      def unevaluated_properties(value = nil)
+        if value.nil?
+          meta_attributes[:unevaluatedProperties] || false
+        else
+          meta_attributes[:unevaluatedProperties] = value
+        end
+      end
+
       # @param [Symbol, nil] version
       # @return [Boolean]
       def schema_version(version = nil)

data/lib/json_model/type_spec/castable.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module JsonModel
+  class TypeSpec
+    class Castable < TypeSpec
+      # @param [String] format
+      # @param [Proc] cast_block
+      def initialize(format:, &cast_block)
+        super()
+        @format = format
+        @cast_block = cast_block
+      end
+
+      # @param [Hash] _options
+      # @return [Hash]
+      def as_schema(**_options)
+        {
+          type: 'string',
+          format: @format,
+        }
+      end
+
+      # @param [::Object] json
+      # @return [::Object, nil]
+      def cast(json)
+        if json.nil?
+          nil
+        else
+          @cast_block.call(json)
+        end
+      end
+    end
+  end
+end

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

@@ -62,7 +62,7 @@ module JsonModel
             end
           },
           uuid: lambda { |v|
-            SecureRandom(v.match?(/\A[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}\z/i))
+            v.match?(/\A[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}\z/i)
           },
           regex: lambda { |v|
             begin
@@ -79,7 +79,7 @@ module JsonModel
         # @param [Integer, nil] min_length
         # @param [Integer, nil] max_length
         # @param [Regexp, nil] pattern
-        # @param [String, nil] format
+        # @param [Symbol, nil] format
         def initialize(min_length: nil, max_length: nil, pattern: nil, format: nil)
           super(types: [::String], schema_type: 'string')
 
@@ -115,7 +115,6 @@ module JsonModel
           end
           if @format
             if JSON_SCHEMA_FORMATS.key?(@format)
-
               register_format_validation(klass, name)
             else
               raise(ArgumentError, "Invalid format: #{@format}")

data/lib/json_model/type_spec.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative('type_spec/array')
+require_relative('type_spec/castable')
 require_relative('type_spec/composition')
 require_relative('type_spec/const')
 require_relative('type_spec/enum')
@@ -9,6 +10,20 @@ require_relative('type_spec/primitive')
 
 module JsonModel
   class TypeSpec
+    TYPE_MAP = {
+      Date => Castable.new(format: 'date') { |v| ::DateTime.iso8601(v) },
+      DateTime => Castable.new(format: 'date-time') { |v| ::DateTime.iso8601(v) },
+      FalseClass => Primitive::Boolean.new,
+      Float => Primitive::Number.new,
+      Integer => Primitive::Integer.new,
+      NilClass => Primitive::Null.new,
+      Regexp => Castable.new(format: 'regex') { |v| Regexp.new(v) },
+      String => Primitive::String.new,
+      Time => Castable.new(format: 'time') { |v| ::Time.iso8601(v) },
+      TrueClass => Primitive::Boolean.new,
+      URI => Castable.new(format: 'uri') { |v| URI.parse(v) },
+    }.freeze
+
     # @param [Hash] options
     # @return [Hash]
     def as_schema(**options)
@@ -32,39 +47,31 @@ 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)
-        if type == String
-          Primitive::String.new(**options)
-        elsif type == Integer
-          Primitive::Integer.new(**options)
-        elsif type == Float
-          Primitive::Number.new(**options)
-        elsif [TrueClass, FalseClass].include?(type)
-          Primitive::Boolean.new(**options)
-        elsif type == NilClass
-          Primitive::Null.new(**options)
+      def resolve_type_from_class(type)
+        if TYPE_MAP.key?(type)
+          TYPE_MAP[type]
         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.14'
+  VERSION = '0.1.16'
 end

data/spec/examples/file_system_spec.rb

@@ -10,7 +10,7 @@ RSpec.describe('File system schema') do
         include(JsonModel::Schema)
 
         property(:type, type: T::Const['disk'])
-        property(:device, type: String, pattern: %r{\A/dev/[^/]+(/[^/]+)*\z})
+        property(:device, type: T::String[pattern: %r{\A/dev/[^/]+(/[^/]+)*\z}])
       end,
     )
 
@@ -22,8 +22,7 @@ RSpec.describe('File system schema') do
         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,
     )
@@ -34,8 +33,8 @@ RSpec.describe('File system schema') do
         include(JsonModel::Schema)
 
         property(:type, type: T::Const['nfs'])
-        property(:remote_path, type: String, pattern: %r{\A(/[^/]+)+\z}, as: :remotePath)
-        property(:server, type: String, format: :ipv4)
+        property(:remote_path, type: T::String[pattern: %r{\A(/[^/]+)+\z}], as: :remotePath)
+        property(:server, type: T::String[format: :ipv4])
       end,
     )
 
@@ -45,7 +44,7 @@ RSpec.describe('File system schema') do
         include(JsonModel::Schema)
 
         property(:type, type: T::Const['tmpfs'])
-        property(:size_in_mb, type: Integer, minimum: 16, maximum: 512, as: :sizeInMB)
+        property(:size_in_mb, type: T::Integer[minimum: 16, maximum: 512], as: :sizeInMB)
       end,
     )
 
@@ -57,12 +56,11 @@ RSpec.describe('File system schema') do
         description('JSON Schema for an fstab entry')
         property(
           :storage,
-          type: T::OneOf[DiskDevice, DiskUuid, Nfs, Tmpfs],
+          type: T::OneOf[DiskDevice, DiskUuid, Nfs, Tmpfs, discriminator: :type],
           ref_mode: JsonModel::RefMode::LOCAL,
-          discriminator: :type,
         )
         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 +98,6 @@ RSpec.describe('File system schema') do
                 type: 'boolean',
               },
             },
-            additionalProperties: false,
             '$defs': {
               DiskDevice: {
                 properties: {
@@ -113,7 +110,6 @@ RSpec.describe('File system schema') do
                   },
                 },
                 required: %i(device type),
-                additionalProperties: false,
                 type: 'object',
               },
               DiskUuid: {
@@ -125,7 +121,6 @@ RSpec.describe('File system schema') do
                   },
                 },
                 required: %i(label type),
-                additionalProperties: false,
                 type: 'object',
               },
               Nfs: {
@@ -141,7 +136,6 @@ RSpec.describe('File system schema') do
                   },
                 },
                 required: %i(remotePath server type),
-                additionalProperties: false,
                 type: 'object',
               },
               Tmpfs: {
@@ -150,7 +144,6 @@ RSpec.describe('File system schema') do
                   sizeInMB: { type: 'integer', minimum: 16, maximum: 512 },
                 },
                 required: %i(sizeInMB type),
-                additionalProperties: false,
                 type: 'object',
               },
             },

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,11 +28,12 @@ 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)
+      property(:birthday, type: Date, optional: true)
     end
 
     stub_const('User', user_class)
@@ -54,8 +55,8 @@ RSpec.describe('User schema') do
                 items: { '$ref': '#/$defs/Address' },
               },
               tags: { type: 'array', items: { type: 'string' } },
+              birthday: { type: 'string', format: 'date' },
             },
-            additionalProperties: false,
             required: %i(addresses email name),
             '$defs': {
               Address: {
@@ -68,7 +69,6 @@ RSpec.describe('User schema') do
                   street: { type: 'string' },
                 },
                 required: %i(city country street),
-                additionalProperties: false,
               },
             },
           },
@@ -77,7 +77,12 @@ RSpec.describe('User schema') do
   end
 
   it('can instantiate a model') do
-    user = User.new(name: 'Foo', email: 'foo@example.com', addresses: [{ street: '123 Main St', city: 'Anytown' }])
+    user = User.new(
+      name: 'Foo',
+      email: 'foo@example.com',
+      addresses: [{ street: '123 Main St', city: 'Anytown' }],
+      birthday: '2000-01-01',
+    )
 
     expect(user.name).to(eq('Foo'))
     expect(user.email).to(eq('foo@example.com'))
@@ -88,5 +93,6 @@ RSpec.describe('User schema') do
     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'))
+    expect(user.birthday).to(eq(Date.new(2000, 1, 1)))
   end
 end

data/spec/schema_meta_spec.rb

@@ -103,9 +103,9 @@ RSpec.describe(JsonModel::SchemaMeta) do
       end
     end
 
-    it('is false by default') do
+    it('is missing by default') do
       expect(klass.meta_attributes)
-        .to(eq({ additionalProperties: false }))
+        .to(eq({}))
     end
 
     it('can be changed') do
@@ -115,4 +115,24 @@ RSpec.describe(JsonModel::SchemaMeta) do
         .to(eq({ additionalProperties: true }))
     end
   end
+
+  describe('.additional_properties') do
+    let(:klass) do
+      Class.new do
+        include(JsonModel::SchemaMeta)
+      end
+    end
+
+    it('is missing by default') do
+      expect(klass.meta_attributes)
+        .to(eq({}))
+    end
+
+    it('can be changed') do
+      klass.unevaluated_properties(true)
+
+      expect(klass.meta_attributes)
+        .to(eq({ unevaluatedProperties: true }))
+    end
+  end
 end

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
 
@@ -100,7 +100,7 @@ RSpec.describe(JsonModel::Schema) do
 
     it('returns an empty schema') do
       expect(klass.as_schema)
-        .to(eq({ type: 'object', additionalProperties: false }))
+        .to(eq({ type: 'object' }))
     end
 
     it('includes the schema id') do
@@ -112,7 +112,6 @@ RSpec.describe(JsonModel::Schema) do
             {
               '$id': 'https://example.com/schemas/example.json',
               type: 'object',
-              additionalProperties: false,
             },
           ),
         )
@@ -145,7 +144,6 @@ RSpec.describe(JsonModel::Schema) do
                 foo: { type: 'string' },
               },
               required: %i(bam baz foo),
-              additionalProperties: false,
             },
           ),
         )
@@ -206,16 +204,13 @@ 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),
@@ -250,7 +245,6 @@ RSpec.describe(JsonModel::Schema) do
                 '$id': 'https://example.com/schemas/child.json',
                 '$ref': 'https://example.com/schemas/example.json',
                 type: 'object',
-                additionalProperties: false,
                 properties: { baz: { type: 'string' } },
                 required: %i(baz),
               },
@@ -265,7 +259,6 @@ RSpec.describe(JsonModel::Schema) do
                 '$ref': 'https://example.com/schemas/example.json',
                 title: 'SecondChild',
                 type: 'object',
-                additionalProperties: false,
                 properties: { bar: { type: 'string' } },
                 required: %i(bar),
               },

data/spec/type_spec/castable_spec.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require('spec_helper')
+
+RSpec.describe(JsonModel::TypeSpec::Castable) do
+  describe('#as_schema') do
+    it('returns a string schema') do
+      expect(described_class.new(format: 'date') { |v| v }.as_schema)
+        .to(eq({ type: 'string', format: 'date' }))
+    end
+  end
+
+  describe('#cast') do
+    it('casts a string') do
+      expect(described_class.new(format: 'date') { |v| Date.parse(v) }.cast('2020-01-01'))
+        .to(eq(Date.new(2020, 1, 1)))
+    end
+  end
+end

data/spec/type_spec/composition_spec.rb

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

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: json_model_rb
 version: !ruby/object:Gem::Version
-  version: 0.1.14
+  version: 0.1.16
 platform: ruby
 authors:
 - Paul Gillesberger
 bindir: bin
 cert_chain: []
-date: 2025-12-30 00:00:00.000000000 Z
+date: 2026-01-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -117,6 +117,7 @@ files:
 - lib/json_model/schema_meta.rb
 - lib/json_model/type_spec.rb
 - lib/json_model/type_spec/array.rb
+- lib/json_model/type_spec/castable.rb
 - lib/json_model/type_spec/composition.rb
 - lib/json_model/type_spec/composition/all_of.rb
 - lib/json_model/type_spec/composition/any_of.rb
@@ -138,10 +139,13 @@ 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
 - spec/examples/file_system_spec.rb
 - spec/examples/user_spec.rb
 - spec/json_model_spec.rb
@@ -151,6 +155,7 @@ files:
 - spec/schema_spec.rb
 - spec/spec_helper.rb
 - spec/type_spec/array_spec.rb
+- spec/type_spec/castable_spec.rb
 - spec/type_spec/composition/all_of_spec.rb
 - spec/type_spec/composition/any_of_spec.rb
 - spec/type_spec/composition/one_of_spec.rb

data/spec/examples/component_spec.rb

@@ -1,57 +0,0 @@
-# frozen_string_literal: true
-
-require('spec_helper')
-
-RSpec.describe('User schema') do
-  it('todo') do
-    stub_const(
-      'BaseComponent',
-      Class.new do
-        include(JsonModel::Schema)
-
-        property(:type, type: String)
-        property(:styles, type: T::Array[String], optional: true)
-      end,
-    )
-    stub_const(
-      'TextComponent',
-      Class.new(BaseComponent) do
-        include(JsonModel::Schema)
-
-        property(:type, type: T::Enum['text'])
-        property(:value, type: String)
-      end,
-    )
-    stub_const(
-      'NumberComponent',
-      Class.new(BaseComponent) do
-        include(JsonModel::Schema)
-
-        property(:type, type: T::Const['number'])
-        property(:value, type: Integer)
-      end,
-    )
-
-    all_component_types = ObjectSpace
-                            .each_object(Class)
-                            .select { |klass| klass.ancestors.include?(BaseComponent) && klass != BaseComponent }
-    stub_const(
-      'GridComponent',
-      Class.new(BaseComponent) do
-        include(JsonModel::Schema)
-
-        property(:type, type: T::Const['grid'])
-        property(:components, type: T::Array[T::OneOf[*all_component_types]], optional: true, ref_mode: JsonModel::RefMode::EXTERNAL)
-      end,
-    )
-
-
-    instance = GridComponent.new(
-      type: 'grid',
-      components: [{ type: 'text', value: 'foo' }, { type: 'number', value: 1 }],
-    )
-
-    expect(instance.components.first).to(be_instance_of(TextComponent))
-    expect(instance.components.last).to(be_instance_of(NumberComponent))
-  end
-end