schemurai 3.0.2 → 3.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dd0769d236e3a91c31ef4e701b642fbcaf76946cb23a11e0a03c230d0f5982d2
-  data.tar.gz: 7b05d25b9825801b5b79c7cdacf8c22bcdd3230dc81ef817e6098c140b1d4686
+  metadata.gz: 663b805a46f6c7bf28678bcc50b2ffae37d3337b3025710a75c0782a5d7c8182
+  data.tar.gz: 41a280754bfa72b41626e44176ef7cf0c983cc27a504aedf049759df005498b1
 SHA512:
-  metadata.gz: 76972d14c8f9682d763e640879d6543effa89d53c6eb2e7b91bcf9cad955f5838e69260e5ec08791c27f582db3f7f90d54252d9c6f0c4f8db219a1ebac98ad67
-  data.tar.gz: fc443ff0789f2f8e3ad95a70f51fc831187da07287c2fafed49cb6fa6999bdb68a1978773de3783b01a217ec39ba482b91ad6cf6d4f4785ac0e13d14a9874731
+  metadata.gz: 88be3ae2e41ce4d46cbb5c79dc66e9bfe7d9041d63619b17dc27dc7977384679435df13f0e234701033eca5f829f9d4e7321b9b08ad8e9b6fdfdf0fa5d64c03c
+  data.tar.gz: a0ea620a03a983a0ad22319c4a22727c316ced09711bd8565a716d8ebcf4c523bc827e957b347c0b19886d487f7529d305b425f63e1e0ffa4b3b7d8f1822e406

data/README.md

@@ -288,9 +288,28 @@ scans use per-item evaluation so successful scans can poll.
 `Schemurai.backend`, `SchemaRegistry#backend`, and `Validator#backend` expose
 the selected backend. Pass `backend: :ruby` to force the Ruby oracle or
 `backend: :vm` to ahead-of-time compile schemas for the validator virtual machine.
-Pass `backend: :native` to use the experimental Rust VM extension. Building the
-native extension requires a C toolchain, Ruby development headers, and Rust
-1.93 or newer. If cargo is absent, gem installation skips the optional native
+Pass `backend: :native` to use the experimental Rust VM extension. Releases
+include precompiled gems on RubyGems.org for CRuby 4.0 on these platforms:
+
+| OS | CPU | libc | Gem platform |
+| --- | --- | --- | --- |
+| Linux | x64 | glibc 2.36+ | `x86_64-linux-gnu` |
+| Linux | arm64 | glibc 2.36+ | `aarch64-linux-gnu` |
+| Linux | x64 | musl (Alpine 3.23+) | `x86_64-linux-musl` |
+| Linux | arm64 | musl (Alpine 3.23+) | `aarch64-linux-musl` |
+| macOS 14+ | x64 | — | `x86_64-darwin` |
+| macOS 14+ | arm64 | — | `arm64-darwin` |
+
+RubyGems/Bundler selects the matching platform gem during normal installation;
+these gems need no C compiler, Rust, or Ruby development headers. Each platform
+gem bundles its supported Ruby minor ABIs and restricts `required_ruby_version`
+to that range. Ruby patch releases share the same binary. To build from source,
+use `gem install schemurai --platform ruby` or Bundler's `force_ruby_platform`.
+See [native gem releases](docs/native-gem-releases.md) for the build matrix.
+
+Building the native extension from source requires a C toolchain, Ruby
+development headers, and Rust 1.93 or newer. If cargo is absent, installation of
+the source gem skips the optional native
 extension and Ruby/VM remain available; explicitly selecting `:native` then
 raises `LoadError`. Native execution borrows Ruby values directly; its current coverage and
 remaining VM delegation are documented below.

data/ext/schemurai_native/Cargo.lock

@@ -67,6 +67,16 @@ dependencies = [
  "num-traits",
 ]
 
+[[package]]
+name = "num-bigint"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "93e7820bc0a80a0238e650327316f929ba18d5be054b647490a3a6a339f3e7c0"
+dependencies = [
+ "num-integer",
+ "num-traits",
+]
+
 [[package]]
 name = "num-integer"
 version = "0.1.47"
@@ -82,7 +92,7 @@ version = "0.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f83d14da390562dca69fc84082e73e548e1ad308d24accdedd2720017cb37824"
 dependencies = [
- "num-bigint",
+ "num-bigint 0.4.8",
  "num-integer",
  "num-traits",
 ]
@@ -127,13 +137,14 @@ checksum = "9774ba4a74de5f7b1c1451ed6cd5285a32eddb5cccb8cc655a4e50009e06477f"
 
 [[package]]
 name = "schemurai-native"
-version = "3.0.2"
+version = "3.1.0"
 dependencies = [
  "base64-simd",
  "base64-turbo",
  "memchr",
- "num-bigint",
+ "num-bigint 0.5.1",
  "num-rational",
+ "num-traits",
  "regex-automata",
  "regex-syntax",
  "ryu",

data/ext/schemurai_native/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "schemurai-native"
-version = "3.0.2"
+version = "3.1.0"
 edition = "2024"
 rust-version = "1.93"
 publish = false
@@ -9,8 +9,9 @@ publish = false
 base64-simd = "0.8.0"
 base64-turbo = "0.5.0"
 memchr = "2.8.3"
-num-bigint = "0.4.8"
-num-rational = "0.4.2"
+num-bigint = "0.5.1"
+num-rational = { version = "0.4.2", default-features = false, features = ["std"] }
+num-traits = "0.2.19"
 regex-automata = "0.4.18"
 regex-syntax = "0.8.11"
 ryu = "1.0.23"

data/ext/schemurai_native/extconf.rb

@@ -2,6 +2,10 @@
 
 require "mkmf"
 
+# Platform gems resolve Ruby symbols from the running interpreter so the same
+# binary also works with Rubies built without a shared libruby.
+$LIBRUBYARG = "" unless enable_config("link-ruby", true) # rubocop:disable Style/GlobalVars -- mkmf build configuration.
+
 unless find_executable("cargo")
   warn "cargo was not found; skipping the optional native backend (Ruby and VM remain available)"
   File.write("Makefile", dummy_makefile(".").join)

data/ext/schemurai_native/src/diagnostics.rs

@@ -713,6 +713,75 @@ impl Execution<'_> {
             if !self.budget.checkpoint() {
                 return Err(Unsupported);
             }
+            // Container entry policy is shared; child traversal stays specific
+            // to each container's paths, assertions and annotation coverage.
+            let container = match op {
+                Op::Array(required, rules) => {
+                    Some((*required, &rules.header, rules.header_only(), TYPE_ARRAY))
+                }
+                Op::Object(required, rules) => {
+                    Some((*required, &rules.header, rules.header_only(), TYPE_OBJECT))
+                }
+                _ => None,
+            };
+            if let Some((required, header, header_only, expected_kind)) = container {
+                if self.caches.report_continuations_allowed()
+                    && !header_only
+                    && (kind == TYPE_UNSUPPORTED
+                        || self.caches.dynamic_calls()
+                        || prior.has_runtime_properties())
+                {
+                    let result = self.caches.container_report(
+                        node,
+                        value,
+                        (source.1, required, expected_kind == TYPE_OBJECT),
+                        report,
+                        &prior,
+                        tracked,
+                    )?;
+                    if tracked {
+                        prior.merge_diagnostics(self, result)?;
+                    }
+                    if report.silent && report.failed {
+                        break;
+                    }
+                    continue;
+                }
+                if header_only && header.runtime_required(self.caches, kind) {
+                    if report.collect_header(self.caches, header, required, value, source)? {
+                        break;
+                    }
+                    continue;
+                }
+                if kind == expected_kind && !self.budget.checkpoint() {
+                    return Err(Unsupported);
+                }
+                if required != 0 && kind != expected_kind {
+                    report.add(self.caches, "type", source, value, 0)?;
+                }
+                if kind != expected_kind {
+                    continue;
+                }
+                if report.silent {
+                    let status = match op {
+                        Op::Array(_, rules) => {
+                            self.array_tracked(rules, value, depth + 1, active, &mut prior)
+                        }
+                        Op::Object(_, rules) => {
+                            self.object_tracked(rules, value, depth + 1, active, &mut prior)
+                        }
+                        _ => unreachable!("container entry"),
+                    };
+                    if status == Unsupported {
+                        return Err(Unsupported);
+                    }
+                    report.failed |= status == Invalid;
+                    if report.failed {
+                        break;
+                    }
+                    continue;
+                }
+            }
             match op {
                 Op::Unsupported => return Err(Unsupported),
                 Op::UnresolvedRef(message) => {
@@ -842,62 +911,7 @@ impl Execution<'_> {
                         }
                     }
                 }
-                Op::Array(required, rules) => {
-                    if self.caches.report_continuations_allowed()
-                        && !rules.header_only()
-                        && (kind == TYPE_UNSUPPORTED
-                            || self.caches.dynamic_calls()
-                            || prior.has_runtime_properties())
-                    {
-                        let result = self.caches.container_report(
-                            node,
-                            value,
-                            (source.1, *required, false),
-                            report,
-                            &prior,
-                            tracked,
-                        )?;
-                        if tracked {
-                            prior.merge_diagnostics(self, result)?;
-                        }
-                        if report.silent && report.failed {
-                            break;
-                        }
-                        continue;
-                    }
-                    if rules.header_only() && rules.header.runtime_required(self.caches, kind) {
-                        if report.collect_header(
-                            self.caches,
-                            &rules.header,
-                            *required,
-                            value,
-                            source,
-                        )? {
-                            break;
-                        }
-                        continue;
-                    }
-                    if kind == TYPE_ARRAY && !self.budget.checkpoint() {
-                        return Err(Unsupported);
-                    }
-                    if *required != 0 && kind != TYPE_ARRAY {
-                        report.add(self.caches, "type", source, value, 0)?;
-                    }
-                    if kind != TYPE_ARRAY {
-                        continue;
-                    }
-                    if report.silent {
-                        let status =
-                            self.array_tracked(rules, value, depth + 1, active, &mut prior);
-                        if status == Unsupported {
-                            return Err(Unsupported);
-                        }
-                        report.failed |= status == Invalid;
-                        if report.failed {
-                            break;
-                        }
-                        continue;
-                    }
+                Op::Array(_, rules) => {
                     let mut coverage = Tracked::new(Valid);
                     let len = unsafe { sn_len(value) };
                     if rules.max.is_some_and(|max| len > max) {
@@ -1168,62 +1182,7 @@ impl Execution<'_> {
                         prior.merge_diagnostics(self, coverage)?;
                     }
                 }
-                Op::Object(required, rules) => {
-                    if self.caches.report_continuations_allowed()
-                        && !rules.header_only()
-                        && (kind == TYPE_UNSUPPORTED
-                            || self.caches.dynamic_calls()
-                            || prior.has_runtime_properties())
-                    {
-                        let result = self.caches.container_report(
-                            node,
-                            value,
-                            (source.1, *required, true),
-                            report,
-                            &prior,
-                            tracked,
-                        )?;
-                        if tracked {
-                            prior.merge_diagnostics(self, result)?;
-                        }
-                        if report.silent && report.failed {
-                            break;
-                        }
-                        continue;
-                    }
-                    if rules.header_only() && rules.header.runtime_required(self.caches, kind) {
-                        if report.collect_header(
-                            self.caches,
-                            &rules.header,
-                            *required,
-                            value,
-                            source,
-                        )? {
-                            break;
-                        }
-                        continue;
-                    }
-                    if kind == TYPE_OBJECT && !self.budget.checkpoint() {
-                        return Err(Unsupported);
-                    }
-                    if *required != 0 && kind != TYPE_OBJECT {
-                        report.add(self.caches, "type", source, value, 0)?;
-                    }
-                    if kind != TYPE_OBJECT {
-                        continue;
-                    }
-                    if report.silent {
-                        let status =
-                            self.object_tracked(rules, value, depth + 1, active, &mut prior);
-                        if status == Unsupported {
-                            return Err(Unsupported);
-                        }
-                        report.failed |= status == Invalid;
-                        if report.failed {
-                            break;
-                        }
-                        continue;
-                    }
+                Op::Object(_, rules) => {
                     let mut coverage = Tracked::new(Valid);
                     let len = unsafe { sn_len(value) };
                     if rules.max.is_some_and(|max| len > max) {

data/ext/schemurai_native/src/number/arbitrary.rs

@@ -3,8 +3,28 @@
 //! method dispatch can invalidate the evaluator's borrowed instance storage.
 use super::*;
 use num_bigint::{BigInt, Sign};
+use num_traits::float::FloatCore;
 use std::borrow::Cow;
 
+// Use the application's BigInt version rather than num-rational's optional one.
+pub(super) type BigRational = num_rational::Ratio<BigInt>;
+
+fn binary_float(value: f64) -> Option<BigRational> {
+    if !value.is_finite() {
+        return None;
+    }
+    let (mantissa, exponent, sign) = value.integer_decode();
+    let numerator = BigInt::from(mantissa) * BigInt::from(sign);
+    Some(if exponent < 0 {
+        BigRational::new(
+            numerator,
+            BigInt::from(1) << exponent.unsigned_abs() as usize,
+        )
+    } else {
+        BigRational::from_integer(numerator << exponent as usize)
+    })
+}
+
 fn integer(value: Value) -> BigInt {
     if unsafe { sn_fixnum(value) } != 0 {
         return BigInt::from(unsafe { sn_integer(value) });
@@ -98,7 +118,7 @@ impl Rules {
         // in binary, but rounds Rational bounds to Float. With multipleOf,
         // Ruby first converts the instance's decimal spelling to a Rational.
         let binary = if actual.is_none() && self.limits.iter().any(|(_, limit)| limit.integer) {
-            BigRational::from_float(n)
+            binary_float(n)
         } else {
             None
         };
@@ -152,3 +172,39 @@ impl Rules {
         Ok(bits)
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn binary_float_preserves_exact_values() {
+        let cases = [
+            (0.0, BigRational::from_integer(BigInt::from(0))),
+            (-0.0, BigRational::from_integer(BigInt::from(0))),
+            (
+                0.1,
+                BigRational::new(BigInt::from(3602879701896397_u64), BigInt::from(1) << 55),
+            ),
+            (
+                f64::from_bits(1),
+                BigRational::new(BigInt::from(1), BigInt::from(1) << 1074),
+            ),
+            (
+                f64::MIN_POSITIVE,
+                BigRational::new(BigInt::from(1), BigInt::from(1) << 1022),
+            ),
+            (
+                f64::MAX,
+                BigRational::from_integer(BigInt::from((1_u64 << 53) - 1) << 971),
+            ),
+        ];
+        for (value, expected) in cases {
+            assert_eq!(binary_float(value), Some(expected.clone()), "{value}");
+            assert_eq!(binary_float(-value), Some(-expected), "{}", -value);
+        }
+        for value in [f64::NAN, f64::INFINITY, f64::NEG_INFINITY] {
+            assert_eq!(binary_float(value), None);
+        }
+    }
+}

data/ext/schemurai_native/src/number.rs

@@ -2,7 +2,7 @@
 //! multipleOf semantics. All evaluation helpers operate under the GVL and
 //! allocate no Ruby objects; unsupported magnitudes retain VM compatibility.
 use super::*;
-use num_rational::BigRational;
+use arbitrary::BigRational;
 use std::cmp::Ordering;
 mod arbitrary;
 

data/lib/schemurai/evaluation_limits.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require_relative "limit_budget"
+
+module Schemurai
+  module Internal
+    # Limit policy shared by evaluators; error storage and scalar state stay local.
+    module EvaluationLimits
+      def validate(instance, max_errors: nil, timeout: nil, budget: nil)
+        with_budget(max_errors, timeout, budget) { super(instance) }
+      end
+
+      def valid?(instance, max_errors: nil, timeout: nil, budget: nil)
+        with_budget(max_errors, timeout, budget) { super(instance) }
+      end
+
+      private def with_budget(max_errors, timeout, budget)
+        @budget = budget || LimitBudget.new(max_errors: max_errors, timeout: timeout)
+        result = yield
+        @budget.check_deadline!
+        result
+      ensure
+        @budget = nil
+      end
+
+      private def evaluate(node, instance)
+        @budget.checkpoint
+        super
+      end
+
+      private def evaluate_valid(node, instance)
+        @budget.checkpoint
+        super
+      end
+
+      private def valid_string?(node, value)
+        @budget.check_deadline!
+        result = super
+        @budget.check_deadline!
+        result
+      end
+
+      private def check_string(node, value)
+        @budget.check_deadline!
+        result = super
+        @budget.check_deadline!
+        result
+      end
+
+      private def valid_content?(schema, value)
+        @budget.check_deadline!
+        result = super
+        @budget.check_deadline!
+        result
+      end
+
+      private def check_content(schema, value)
+        @budget.check_deadline!
+        result = super
+        @budget.check_deadline!
+        result
+      end
+    end
+  end
+end

data/lib/schemurai/limited_evaluator.rb

@@ -1,63 +1,20 @@
 # frozen_string_literal: true
 
 require_relative "limit_exceeded"
-require_relative "limit_budget"
+require_relative "evaluation_limits"
 require_relative "evaluator"
 
 module Schemurai
   module Internal
     # Ruby evaluation with invocation-local limits.
     class LimitedEvaluator < Evaluator
-      def validate(instance, max_errors: nil, timeout: nil, budget: nil)
-        @budget = budget || LimitBudget.new(max_errors: max_errors, timeout: timeout)
-        errors = []
-        each_error(instance) do |error|
-          errors << error
-        end
-        @budget.check_deadline!
-        Result.new(errors)
-      ensure
-        @budget = nil
-      end
-
-      def valid?(instance, max_errors: nil, timeout: nil, budget: nil)
-        @budget = budget || LimitBudget.new(max_errors: max_errors, timeout: timeout)
-        result = super(instance)
-        @budget.check_deadline!
-        result
-      ensure
-        @budget = nil
-      end
-
-      private def evaluate(node, instance)
-        @budget.checkpoint
-        super
-      end
-
-      private def evaluate_valid(node, instance)
-        @budget.checkpoint
-        super
-      end
+      include EvaluationLimits
 
       private def add_error(keyword, message = nil, append_keyword: true, &block)
         @budget.reserve_error if @error_callback
         super
       end
 
-      private def valid_string?(node, value)
-        @budget.check_deadline!
-        result = super
-        @budget.check_deadline!
-        result
-      end
-
-      private def check_string(node, value)
-        @budget.check_deadline!
-        result = super
-        @budget.check_deadline!
-        result
-      end
-
       private def decimal(value)
         @budget.check_deadline!
         result = super
@@ -72,20 +29,6 @@ module Schemurai
         result
       end
 
-      private def valid_content?(schema, value)
-        @budget.check_deadline!
-        result = super
-        @budget.check_deadline!
-        result
-      end
-
-      private def check_content(schema, value)
-        @budget.check_deadline!
-        result = super
-        @budget.check_deadline!
-        result
-      end
-
       private def json_equal?(left, right)
         @budget.checkpoint
         super

data/lib/schemurai/version.rb

@@ -2,5 +2,5 @@
 
 module Schemurai
   # The installed Schemurai version.
-  VERSION = "3.0.2"
+  VERSION = "3.1.0"
 end

data/lib/schemurai/vm/limited_evaluator.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "../limit_exceeded"
-require_relative "../limit_budget"
+require_relative "../evaluation_limits"
 require_relative "evaluator"
 
 module Schemurai
@@ -10,73 +10,18 @@ module Schemurai
     class LimitedEvaluator < Evaluator
       include Internal::ValueEquality::Checkpoints
       include Internal::StringChecks::TimedRegexps
-
-      def validate(instance, max_errors: nil, timeout: nil, budget: nil)
-        @budget = budget || Internal::LimitBudget.new(max_errors: max_errors, timeout: timeout)
-        result = super(instance)
-        @budget.check_deadline!
-        result
-      ensure
-        @budget = nil
-      end
-
-      def valid?(instance, max_errors: nil, timeout: nil, budget: nil)
-        @budget = budget || Internal::LimitBudget.new(max_errors: max_errors, timeout: timeout)
-        result = super(instance)
-        @budget.check_deadline!
-        result
-      ensure
-        @budget = nil
-      end
-
-      private def evaluate(node, instance)
-        @budget.checkpoint
-        super
-      end
-
-      private def evaluate_valid(node, instance)
-        @budget.checkpoint
-        super
-      end
+      include Internal::EvaluationLimits
 
       private def add_error(keyword, message = nil, append_keyword: true, &block)
         @budget.reserve_error if @errors
         super
       end
 
-      private def valid_string?(node, value)
-        @budget.check_deadline!
-        result = super
-        @budget.check_deadline!
-        result
-      end
-
-      private def check_string(node, value)
-        @budget.check_deadline!
-        result = super
-        @budget.check_deadline!
-        result
-      end
-
       private def number_state
         state = super
         state.budget = @budget
         state
       end
-
-      private def valid_content?(schema, value)
-        @budget.check_deadline!
-        result = super
-        @budget.check_deadline!
-        result
-      end
-
-      private def check_content(schema, value)
-        @budget.check_deadline!
-        result = super
-        @budget.check_deadline!
-        result
-      end
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: schemurai
 version: !ruby/object:Gem::Version
-  version: 3.0.2
+  version: 3.1.0
 platform: ruby
 authors:
 - Kuya KOHARA (oakcask)
@@ -84,6 +84,7 @@ files:
 - lib/schemurai/ecma_regexp.rb
 - lib/schemurai/error_message.rb
 - lib/schemurai/evaluation.rb
+- lib/schemurai/evaluation_limits.rb
 - lib/schemurai/evaluation_pool.rb
 - lib/schemurai/evaluator.rb
 - lib/schemurai/formats.rb
@@ -117,7 +118,7 @@ licenses:
 metadata:
   homepage_uri: https://github.com/oakcask/schemurai
   source_code_uri: https://github.com/oakcask/schemurai/tree/main
-  documentation_uri: https://rubydoc.info/gems/schemurai/3.0.2
+  documentation_uri: https://rubydoc.info/gems/schemurai/3.1.0
   rubygems_mfa_required: 'true'
 rdoc_options:
 - "--main"