philiprehberger-json_schema 0.2.3 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 143f39a54828b31d7a745796701be504fc920b45bf6854216d12310fedcc1a18
-  data.tar.gz: 662b04162211c5b5d85efb5a0b378c21da0f54457866485c94e3760388662d29
+  metadata.gz: 2a67bbf9af3550800b697cffb7061d297e1cc4d4d658b1db1f4c3eb3133c5125
+  data.tar.gz: a805669bc1f806de5fd76ac8ff9b28414676b2772ef71c67bdbad40ba5ebf66d
 SHA512:
-  metadata.gz: b9b492cac2a6bfa9d117979d5ba899b41b88c187373f99073cee4d46ab2a5b8c0e3e2de340ea68d40538b99f54c65a240b8ff04703d5a4a885076cb993c991eb
-  data.tar.gz: b18f7bef9389eae54ba47f7c5caf3d2c6de778a7923ff2bd0e14838b86861d25bca489fada64f73606c490f740769d75d263ee2cefb32e3cdc69669f57cbd9da
+  metadata.gz: f14027b317fc2d9b1f36dd79351e5da1ef2b43ebe14a00877cff83221db2e2e63d5802f5142389147285fd020992d5338583850947edb49f244383157710aa17
+  data.tar.gz: 4290e58110711d0ad8e9ed236d4d7dbea255621ca7dd985a48e63fe2c20b100545fbca3b5437406653fd448a54b74f44cfcdbb45a4ed22ffcd1c4f49b8fad3fe

data/CHANGELOG.md

@@ -7,6 +7,15 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.3.0] - 2026-04-17
+
+### Added
+- `exclusiveMinimum` and `exclusiveMaximum` keywords for strict numeric bounds
+- `multipleOf` keyword, using BigDecimal arithmetic to avoid IEEE-754 drift on fractional multiples
+- `uniqueItems` keyword for arrays (deep equality on nested values)
+- `minProperties` and `maxProperties` keywords for object property-count constraints
+- README: Usage examples for the new keywords and expanded Supported Keywords table
+
 ## [0.2.3] - 2026-04-09
 
 ### Fixed

data/README.md

@@ -141,6 +141,39 @@ Philiprehberger::JsonSchema.valid?('fixed_value', schema)  # => true
 Philiprehberger::JsonSchema.valid?('other', schema)        # => false
 ```
 
+### Numeric Bounds (exclusive and multipleOf)
+
+```ruby
+# exclusive bounds
+schema = { type: 'integer', exclusiveMinimum: 0, exclusiveMaximum: 10 }
+Philiprehberger::JsonSchema.valid?(5, schema)   # => true
+Philiprehberger::JsonSchema.valid?(0, schema)   # => false (equal to exclusiveMinimum)
+Philiprehberger::JsonSchema.valid?(10, schema)  # => false (equal to exclusiveMaximum)
+
+# multipleOf (BigDecimal-backed, safe for fractions)
+schema = { type: 'number', multipleOf: 0.1 }
+Philiprehberger::JsonSchema.valid?(0.3, schema)   # => true
+Philiprehberger::JsonSchema.valid?(0.25, schema)  # => false
+```
+
+### Unique Array Items
+
+```ruby
+schema = { type: 'array', uniqueItems: true }
+Philiprehberger::JsonSchema.valid?([1, 2, 3], schema)                     # => true
+Philiprehberger::JsonSchema.valid?([1, 2, 2], schema)                     # => false
+Philiprehberger::JsonSchema.valid?([{ 'a' => 1 }, { 'a' => 1 }], schema)  # => false (deep equality)
+```
+
+### Object Property Counts
+
+```ruby
+schema = { type: 'object', minProperties: 1, maxProperties: 3 }
+Philiprehberger::JsonSchema.valid?({ 'a' => 1 }, schema)                               # => true
+Philiprehberger::JsonSchema.valid?({}, schema)                                          # => false
+Philiprehberger::JsonSchema.valid?({ 'a' => 1, 'b' => 2, 'c' => 3, 'd' => 4 }, schema) # => false
+```
+
 ### Compiled Schemas
 
 ```ruby
@@ -182,11 +215,15 @@ compiled.validate({ 'id' => 'x' }) # => ["$.id: expected type integer..."]
 | `patternProperties` | Regex-keyed sub-schemas for matching property names |
 | `pattern` | Regex match for strings |
 | `minLength` / `maxLength` | String length constraints |
-| `minimum` / `maximum` | Numeric range constraints |
+| `minimum` / `maximum` | Numeric range constraints (inclusive) |
+| `exclusiveMinimum` / `exclusiveMaximum` | Numeric range constraints (exclusive) |
+| `multipleOf` | Value must be a multiple of the given number (BigDecimal-backed) |
 | `enum` | Allowed value list |
 | `const` | Exact value match |
 | `items` | Schema for array elements |
 | `minItems` / `maxItems` | Array length constraints |
+| `uniqueItems` | Require all array items to be unique (deep equality) |
+| `minProperties` / `maxProperties` | Object property-count constraints |
 | `allOf` | Data must match all sub-schemas |
 | `anyOf` | Data must match at least one sub-schema |
 | `oneOf` | Data must match exactly one sub-schema |

data/lib/philiprehberger/json_schema/validator.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'bigdecimal'
+
 module Philiprehberger
   module JsonSchema
     # Core validation engine that checks data against a JSON Schema (draft-07 subset)
@@ -18,15 +20,19 @@ module Philiprehberger
         validate_type(data, schema, path, errors)
         validate_const(data, schema, path, errors)
         validate_required(data, schema, path, errors)
+        validate_object_size(data, schema, path, errors)
         validate_properties(data, schema, path, errors, root_schema)
         validate_additional_properties(data, schema, path, errors, root_schema)
         validate_pattern_properties(data, schema, path, errors, root_schema)
         validate_pattern(data, schema, path, errors)
         validate_string_length(data, schema, path, errors)
         validate_numeric_range(data, schema, path, errors)
+        validate_exclusive_range(data, schema, path, errors)
+        validate_multiple_of(data, schema, path, errors)
         validate_enum(data, schema, path, errors)
         validate_items(data, schema, path, errors, root_schema)
         validate_array_length(data, schema, path, errors)
+        validate_unique_items(data, schema, path, errors)
         validate_ref(data, schema, path, errors, root_schema)
         validate_all_of(data, schema, path, errors, root_schema)
         validate_any_of(data, schema, path, errors, root_schema)
@@ -176,6 +182,31 @@ module Philiprehberger
         errors << "#{path}: value #{data} is greater than maximum #{max}" if max && data > max
       end
 
+      def validate_exclusive_range(data, schema, path, errors)
+        return unless data.is_a?(Numeric) && !data.is_a?(Complex)
+
+        excl_min = schema_key(schema, :exclusiveMinimum)
+        excl_max = schema_key(schema, :exclusiveMaximum)
+
+        min_violated = excl_min.is_a?(Numeric) && data <= excl_min
+        max_violated = excl_max.is_a?(Numeric) && data >= excl_max
+
+        errors << "#{path}: value #{data} is not greater than exclusiveMinimum #{excl_min}" if min_violated
+        errors << "#{path}: value #{data} is not less than exclusiveMaximum #{excl_max}" if max_violated
+      end
+
+      def validate_multiple_of(data, schema, path, errors)
+        return unless data.is_a?(Numeric) && !data.is_a?(Complex)
+
+        multiple = schema_key(schema, :multipleOf)
+        return unless multiple.is_a?(Numeric) && multiple.positive? && multiple.finite?
+
+        # Use BigDecimal via string representation to sidestep IEEE-754 drift
+        # (e.g. 0.3 % 0.1 != 0 in Float arithmetic).
+        remainder = BigDecimal(data.to_s) % BigDecimal(multiple.to_s)
+        errors << "#{path}: value #{data} is not a multiple of #{multiple}" unless remainder.zero?
+      end
+
       def validate_enum(data, schema, path, errors)
         allowed = schema_key(schema, :enum)
         return unless allowed.is_a?(Array)
@@ -204,6 +235,29 @@ module Philiprehberger
         errors << "#{path}: array length #{data.length} is greater than maxItems #{max}" if max && data.length > max
       end
 
+      def validate_unique_items(data, schema, path, errors)
+        return unless data.is_a?(Array)
+
+        unique = schema_key(schema, :uniqueItems)
+        return unless unique == true
+
+        errors << "#{path}: array items are not unique" if data.length != data.uniq.length
+      end
+
+      def validate_object_size(data, schema, path, errors)
+        return unless data.is_a?(Hash)
+
+        min = schema_key(schema, :minProperties)
+        max = schema_key(schema, :maxProperties)
+        size = data.size
+
+        under_min = min.is_a?(Integer) && size < min
+        over_max = max.is_a?(Integer) && size > max
+
+        errors << "#{path}: object has #{size} properties, expected at least #{min}" if under_min
+        errors << "#{path}: object has #{size} properties, expected at most #{max}" if over_max
+      end
+
       def validate_ref(data, schema, path, errors, root_schema)
         ref = schema_key(schema, '$ref')
         return unless ref.is_a?(String)

data/lib/philiprehberger/json_schema/version.rb

@@ -2,6 +2,6 @@
 
 module Philiprehberger
   module JsonSchema
-    VERSION = '0.2.3'
+    VERSION = '0.3.0'
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: philiprehberger-json_schema
 version: !ruby/object:Gem::Version
-  version: 0.2.3
+  version: 0.3.0
 platform: ruby
 authors:
 - Philip Rehberger
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-04-09 00:00:00.000000000 Z
+date: 2026-04-17 00:00:00.000000000 Z
 dependencies: []
 description: Validate Ruby data structures against JSON Schema definitions with support
   for type checking, required properties, pattern matching, numeric ranges, enums,