jsonschema_rs 0.42.0-aarch64-linux

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 29e5bf1c85875f60a2e1d02f769b203839c377a3d72c63f8ae0aecf3c47ed7b3
+  data.tar.gz: 30e5f0a7e3e427eb2b1d4f5d34b995cf79c2b3fe06649b1a3d3a804d74f85e1f
+SHA512:
+  metadata.gz: 226a01d9b43a84e8e29cd2c373ff133a79fb0c9b7ff151d760040b5b8314a22efb873748f95e5a72afdcfd980099cedcdc8aed3004379d8920248912876c0b13
+  data.tar.gz: 921ca6bae055f06fbd00f9e680102b67ff69f87ee8b69e7f1cbb29235e02917b894b652a60676429e65831062259f063eb07968eef72356d255f48521dfe9a5c

data/CHANGELOG.md

@@ -0,0 +1,8 @@
+# Changelog
+
+## [Unreleased]
+
+## 0.42.0 - 2026-02-15
+
+- Initial public release
+

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020-2026 Dmitry Dygalo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/MIGRATION.md

@@ -0,0 +1,87 @@
+# Migrating from json_schemer
+
+## Quick Reference
+
+| json_schemer | jsonschema |
+|---|---|
+| `JSONSchemer.schema(s)` | `JSONSchema.validator_for(s)` |
+| `JSONSchemer.schema(s, meta_schema: 'draft7')` | `JSONSchema::Draft7Validator.new(s)` |
+| `schemer.valid?(d)` | `validator.valid?(d)` |
+| `schemer.validate(d)` | `validator.each_error(d)` |
+| `schemer.validate!(d)` | `validator.validate!(d)` |
+| `JSONSchemer.valid?(s, d)` | `JSONSchema.valid?(s, d)` |
+| `JSONSchemer.valid_schema?(s)` | `JSONSchema::Meta.valid?(s)` |
+| `error["data_pointer"]` | `error.instance_path_pointer` |
+| `error["schema_pointer"]` | `error.schema_path_pointer` |
+| `error["type"]` | `error.kind.name` |
+| `error["error"]` | `error.message` |
+| `ref_resolver: proc` | `retriever: proc` |
+| `format: true` | `validate_formats: true` |
+
+Draft-specific validators are also available: `JSONSchema::Draft7Validator.new(schema)`
+
+## What Stays the Same
+
+- JSON Schema documents work as-is
+- `valid?` and `validate!` method names
+- Custom format validators via `formats:` with the same proc syntax
+- One-off validation: `JSONSchema.valid?(schema, data)`
+
+## Error Objects
+
+json_schemer returns hashes, jsonschema returns `ValidationError` objects:
+
+```ruby
+# json_schemer
+error["data_pointer"]    # => "/foo/bar"
+error["schema_pointer"]  # => "/properties/foo/minimum"
+error["type"]            # => "minimum"
+error["error"]           # => "value is less than 10"
+
+# jsonschema
+error.instance_path            # => ["foo", "bar"]
+error.instance_path_pointer    # => "/foo/bar"  (same format as data_pointer)
+error.schema_path              # => ["properties", "foo", "minimum"]
+error.schema_path_pointer      # => "/properties/foo/minimum"
+error.kind.name                # => "minimum"
+error.message                  # => "value is less than 10"
+
+# Need a hash? Use to_h on error kind
+error.kind.to_h        # => { "name" => "minimum", "value" => { "limit" => 10 } }
+```
+
+## Reference Resolution
+
+```ruby
+# json_schemer
+JSONSchemer.schema(schema, ref_resolver: refs.to_proc)
+
+# jsonschema — retriever
+JSONSchema.validator_for(schema, retriever: ->(uri) { fetch_schema(uri) })
+
+# jsonschema — registry
+registry = JSONSchema::Registry.new([["http://example.com/s", sub_schema]])
+JSONSchema.validator_for(schema, registry: registry)
+```
+
+## What You Gain
+
+- **Structured output** — `evaluate` API with flag, list, and hierarchical output formats
+- **Custom keywords** — extend JSON Schema with domain-specific validation rules
+- **Error masking** — hide sensitive data in error messages with `mask:`
+- **Regex engine configuration** — choose between fancy-regex (default) and linear-time regex
+- **Email validation options** — fine-grained control over email format validation
+
+## Not Supported
+
+- `insert_property_defaults` — jsonschema is a validator, not a data transformer
+- OpenAPI document parsing — use a dedicated OpenAPI library
+
+## Migration Checklist
+
+- [ ] Replace `JSONSchemer.schema` with `JSONSchema.validator_for`
+- [ ] Replace `validate` (error iteration) with `each_error`
+- [ ] Replace `ref_resolver:` with `retriever:` or use `Registry`
+- [ ] Replace `format: true` with `validate_formats: true`
+- [ ] Replace `meta_schema: 'draft7'` with `JSONSchema::Draft7Validator.new(s)` or `draft: :draft7` on one-off functions
+- [ ] Update error handling from hash access to `ValidationError` attributes

data/README.md

@@ -0,0 +1,489 @@
+# jsonschema_rs
+
+[![Build](https://img.shields.io/github/actions/workflow/status/Stranger6667/jsonschema/ci.yml?branch=master&style=flat-square)](https://github.com/Stranger6667/jsonschema/actions)
+[![Version](https://img.shields.io/gem/v/jsonschema_rs.svg?style=flat-square)](https://rubygems.org/gems/jsonschema_rs)
+[![Ruby versions](https://img.shields.io/badge/ruby-3.2%20%7C%203.4%20%7C%204.0-blue?style=flat-square)](https://rubygems.org/gems/jsonschema_rs)
+[<img alt="Supported Dialects" src="https://img.shields.io/endpoint?url=https%3A%2F%2Fbowtie.report%2Fbadges%2Frust-jsonschema%2Fsupported_versions.json&style=flat-square">](https://bowtie.report/#/implementations/rust-jsonschema)
+
+A high-performance JSON Schema validator for Ruby.
+
+```ruby
+require 'jsonschema_rs'
+
+schema = { "maxLength" => 5 }
+instance = "foo"
+
+# One-off validation
+JSONSchema.valid?(schema, instance)  # => true
+
+begin
+  JSONSchema.validate!(schema, "incorrect")
+rescue JSONSchema::ValidationError => e
+  puts e.message  # => "\"incorrect\" is longer than 5 characters"
+end
+
+# Build & reuse (faster)
+validator = JSONSchema.validator_for(schema)
+
+# Iterate over errors
+validator.each_error(instance) do |error|
+  puts "Error: #{error.message}"
+  puts "Location: #{error.instance_path}"
+end
+
+# Boolean result
+validator.valid?(instance)  # => true
+
+# Structured output (JSON Schema Output v1)
+evaluation = validator.evaluate(instance)
+evaluation.annotations.each do |ann|
+  puts "Annotation at #{ann[:schemaLocation]}: #{ann[:annotations]}"
+end
+```
+
+> **Migrating from `json_schemer`?** See the [migration guide](MIGRATION.md).
+
+## Highlights
+
+- 📚 Full support for popular JSON Schema drafts
+- 🌐 Remote reference fetching (network/file)
+- 🔧 Custom keywords and format validators
+- ✨ Meta-schema validation for schema documents
+- ♦️ Supports Ruby 3.2, 3.4 and 4.0
+
+### Supported drafts
+
+The following drafts are supported:
+
+- [![Draft 2020-12](https://img.shields.io/endpoint?url=https%3A%2F%2Fbowtie.report%2Fbadges%2Frust-jsonschema%2Fcompliance%2Fdraft2020-12.json)](https://bowtie.report/#/implementations/rust-jsonschema)
+- [![Draft 2019-09](https://img.shields.io/endpoint?url=https%3A%2F%2Fbowtie.report%2Fbadges%2Frust-jsonschema%2Fcompliance%2Fdraft2019-09.json)](https://bowtie.report/#/implementations/rust-jsonschema)
+- [![Draft 7](https://img.shields.io/endpoint?url=https%3A%2F%2Fbowtie.report%2Fbadges%2Frust-jsonschema%2Fcompliance%2Fdraft7.json)](https://bowtie.report/#/implementations/rust-jsonschema)
+- [![Draft 6](https://img.shields.io/endpoint?url=https%3A%2F%2Fbowtie.report%2Fbadges%2Frust-jsonschema%2Fcompliance%2Fdraft6.json)](https://bowtie.report/#/implementations/rust-jsonschema)
+- [![Draft 4](https://img.shields.io/endpoint?url=https%3A%2F%2Fbowtie.report%2Fbadges%2Frust-jsonschema%2Fcompliance%2Fdraft4.json)](https://bowtie.report/#/implementations/rust-jsonschema)
+
+You can check the current status on the [Bowtie Report](https://bowtie.report/#/implementations/rust-jsonschema).
+
+## Installation
+
+Add to your Gemfile:
+
+```
+gem 'jsonschema_rs'
+```
+
+Pre-built native gems are available for:
+
+- **Linux**: `x86_64`, `aarch64` (glibc and musl)
+- **macOS**: `x86_64`, `arm64`
+- **Windows**: `x64` (mingw-ucrt)
+
+If no pre-built gem is available for your platform, it will be compiled from source during installation. You'll need:
+- Ruby 3.2+
+- Rust toolchain ([rustup](https://rustup.rs/))
+
+## Usage
+
+### Reusable validators
+
+For validating multiple instances against the same schema, create a reusable validator.
+`validator_for` automatically detects the draft version from the `$schema` keyword in the schema:
+
+```ruby
+validator = JSONSchema.validator_for({
+  "type" => "object",
+  "properties" => {
+    "name" => { "type" => "string" },
+    "age" => { "type" => "integer", "minimum" => 0 }
+  },
+  "required" => ["name"]
+})
+
+validator.valid?({ "name" => "Alice", "age" => 30 })  # => true
+validator.valid?({ "age" => 30 })                      # => false
+```
+
+You can use draft-specific validators for different JSON Schema versions:
+
+```ruby
+validator = JSONSchema::Draft7Validator.new(schema)
+
+# Available: Draft4Validator, Draft6Validator, Draft7Validator,
+#            Draft201909Validator, Draft202012Validator
+```
+
+### Custom format validators
+
+```ruby
+phone_format = ->(value) { value.match?(/^\+?[1-9]\d{1,14}$/) }
+
+validator = JSONSchema.validator_for(
+  { "type" => "string", "format" => "phone" },
+  validate_formats: true,
+  formats: { "phone" => phone_format }
+)
+```
+
+### Custom keyword validators
+
+```ruby
+class EvenValidator
+  def initialize(parent_schema, value, schema_path)
+    @enabled = value
+  end
+
+  def validate(instance)
+    return unless @enabled && instance.is_a?(Integer)
+    raise "#{instance} is not even" if instance.odd?
+  end
+end
+
+validator = JSONSchema.validator_for(
+  { "type" => "integer", "even" => true },
+  keywords: { "even" => EvenValidator }
+)
+```
+
+Each custom keyword class must implement:
+- `initialize(parent_schema, value, schema_path)` - called during schema compilation
+- `validate(instance)` - raise on failure, return normally on success
+
+### Structured evaluation output
+
+When you need more than a boolean result, use the `evaluate` API to access the JSON Schema Output v1 formats:
+
+```ruby
+schema = {
+  "type" => "object",
+  "properties" => {
+    "name" => { "type" => "string" },
+    "age" => { "type" => "integer" }
+  },
+  "required" => ["name"]
+}
+validator = JSONSchema.validator_for(schema)
+
+evaluation = validator.evaluate({ "age" => "not_an_integer" })
+
+evaluation.valid?  # => false
+
+# Flag output (simplest)
+evaluation.flag
+# => { "valid" => false }
+
+# List output (flat)
+evaluation.list
+# => { "valid" => false, "details" => [
+#   { "valid" => false, "evaluationPath" => "", "instanceLocation" => "", "schemaLocation" => "" },
+#   { "valid" => false, "evaluationPath" => "/required", "instanceLocation" => "", "schemaLocation" => "/required",
+#     "errors" => { "required" => "\"name\" is a required property" } },
+#   ...
+# ] }
+
+# Hierarchical output (nested tree following schema structure)
+evaluation.hierarchical
+# => { "valid" => false, "evaluationPath" => "", "instanceLocation" => "", "schemaLocation" => "",
+#   "details" => [ ... ] }
+
+# Collected errors across all nodes
+evaluation.errors
+# => [{ "schemaLocation" => "/required", "instanceLocation" => "",
+#        "absoluteKeywordLocation" => nil, "error" => "\"name\" is a required property" }, ...]
+
+# Collected annotations
+evaluation.annotations
+# => [{ "schemaLocation" => "/properties", "instanceLocation" => "",
+#        "absoluteKeywordLocation" => nil, "annotations" => ["age"] }]
+```
+
+## Meta-Schema Validation
+
+Validate that a JSON Schema document is itself valid:
+
+```ruby
+JSONSchema::Meta.valid?({ "type" => "string" })      # => true
+JSONSchema::Meta.valid?({ "type" => "invalid_type" }) # => false
+
+begin
+  JSONSchema::Meta.validate!({ "type" => 123 })
+rescue JSONSchema::ValidationError => e
+  e.message  # => "123 is not valid under any of the schemas listed in the 'anyOf' keyword"
+end
+```
+
+## External References
+
+By default, `jsonschema` resolves HTTP references and file references from the local file system. You can implement a custom retriever to handle external references:
+
+```ruby
+schemas = {
+  "https://example.com/person.json" => {
+    "type" => "object",
+    "properties" => {
+      "name" => { "type" => "string" },
+      "age" => { "type" => "integer" }
+    },
+    "required" => ["name", "age"]
+  }
+}
+
+retriever = ->(uri) { schemas[uri] }
+
+schema = { "$ref" => "https://example.com/person.json" }
+validator = JSONSchema.validator_for(schema, retriever: retriever)
+
+validator.valid?({ "name" => "Alice", "age" => 30 })  # => true
+validator.valid?({ "name" => "Bob" })                  # => false (missing "age")
+```
+
+## Schema Registry
+
+For applications that frequently use the same schemas, create a registry to store and reference them:
+
+```ruby
+registry = JSONSchema::Registry.new([
+  ["https://example.com/address.json", {
+    "type" => "object",
+    "properties" => {
+      "street" => { "type" => "string" },
+      "city" => { "type" => "string" }
+    }
+  }],
+  ["https://example.com/person.json", {
+    "type" => "object",
+    "properties" => {
+      "name" => { "type" => "string" },
+      "address" => { "$ref" => "https://example.com/address.json" }
+    }
+  }]
+])
+
+validator = JSONSchema.validator_for(
+  { "$ref" => "https://example.com/person.json" },
+  registry: registry
+)
+
+validator.valid?({
+  "name" => "John",
+  "address" => { "street" => "Main St", "city" => "Boston" }
+})  # => true
+```
+
+The registry also accepts `draft:` and `retriever:` options:
+
+```ruby
+registry = JSONSchema::Registry.new(
+  [["https://example.com/person.json", schemas["https://example.com/person.json"]]],
+  draft: :draft7,
+  retriever: retriever
+)
+```
+
+## Regular Expression Configuration
+
+When validating schemas with regex patterns (in `pattern` or `patternProperties`), you can configure the underlying regex engine:
+
+```ruby
+# Default fancy-regex engine with backtracking limits
+# (supports lookaround and backreferences but needs protection against DoS)
+validator = JSONSchema.validator_for(
+  { "type" => "string", "pattern" => "^(a+)+$" },
+  pattern_options: JSONSchema::FancyRegexOptions.new(backtrack_limit: 10_000)
+)
+
+# Standard regex engine for guaranteed linear-time matching
+# (prevents regex DoS attacks but supports fewer features)
+validator = JSONSchema.validator_for(
+  { "type" => "string", "pattern" => "^a+$" },
+  pattern_options: JSONSchema::RegexOptions.new
+)
+
+# Both engines support memory usage configuration
+validator = JSONSchema.validator_for(
+  { "type" => "string", "pattern" => "^a+$" },
+  pattern_options: JSONSchema::RegexOptions.new(
+    size_limit: 1024 * 1024,   # Maximum compiled pattern size
+    dfa_size_limit: 10240       # Maximum DFA cache size
+  )
+)
+```
+
+The available options:
+
+  - `FancyRegexOptions`: Default engine with lookaround and backreferences support
+
+    - `backtrack_limit`: Maximum backtracking steps
+    - `size_limit`: Maximum compiled regex size in bytes
+    - `dfa_size_limit`: Maximum DFA cache size in bytes
+
+  - `RegexOptions`: Safer engine with linear-time guarantee
+
+    - `size_limit`: Maximum compiled regex size in bytes
+    - `dfa_size_limit`: Maximum DFA cache size in bytes
+
+This configuration is crucial when working with untrusted schemas where attackers might craft malicious regex patterns.
+
+## Email Format Configuration
+
+When validating email addresses using `{"format": "email"}`, you can customize the validation behavior:
+
+```ruby
+# Require a top-level domain (reject "user@localhost")
+validator = JSONSchema.validator_for(
+  { "format" => "email", "type" => "string" },
+  validate_formats: true,
+  email_options: JSONSchema::EmailOptions.new(require_tld: true)
+)
+validator.valid?("user@localhost")    # => false
+validator.valid?("user@example.com") # => true
+
+# Disallow IP address literals and display names
+validator = JSONSchema.validator_for(
+  { "format" => "email", "type" => "string" },
+  validate_formats: true,
+  email_options: JSONSchema::EmailOptions.new(
+    allow_domain_literal: false,  # Reject "user@[127.0.0.1]"
+    allow_display_text: false     # Reject "Name <user@example.com>"
+  )
+)
+
+# Require minimum domain segments
+validator = JSONSchema.validator_for(
+  { "format" => "email", "type" => "string" },
+  validate_formats: true,
+  email_options: JSONSchema::EmailOptions.new(minimum_sub_domains: 3)  # e.g., user@sub.example.com
+)
+```
+
+Available options:
+
+  - `require_tld`: Require a top-level domain (e.g., reject "user@localhost")
+  - `allow_domain_literal`: Allow IP address literals like "user@[127.0.0.1]" (default: true)
+  - `allow_display_text`: Allow display names like "Name <user@example.com>" (default: true)
+  - `minimum_sub_domains`: Minimum number of domain segments required
+
+## Error Handling
+
+`jsonschema` provides detailed validation errors through the `ValidationError` class:
+
+```ruby
+schema = { "type" => "string", "maxLength" => 5 }
+
+begin
+  JSONSchema.validate!(schema, "too long")
+rescue JSONSchema::ValidationError => error
+  # Basic error information
+  error.message         # => '"too long" is longer than 5 characters'
+  error.verbose_message # => Full context with schema path and instance
+  error.instance_path   # => Location in the instance that failed
+  error.schema_path     # => Location in the schema that failed
+
+  # Detailed error information via `kind`
+  error.kind.name       # => "maxLength"
+  error.kind.value      # => { "limit" => 5 }
+  error.kind.to_h       # => { "name" => "maxLength", "value" => { "limit" => 5 } }
+end
+```
+
+### Error Kind Properties
+
+Each error has a `kind` property with convenient accessors:
+
+```ruby
+JSONSchema.each_error({ "minimum" => 5 }, 3).each do |error|
+  error.kind.name   # => "minimum"
+  error.kind.value  # => { "limit" => 5 }
+  error.kind.to_h   # => { "name" => "minimum", "value" => { "limit" => 5 } }
+  error.kind.to_s   # => "minimum"
+end
+```
+
+### Error Message Masking
+
+When working with sensitive data, you can mask instance values in error messages:
+
+```ruby
+schema = {
+  "type" => "object",
+  "properties" => {
+    "password" => { "type" => "string", "minLength" => 8 },
+    "api_key" => { "type" => "string", "pattern" => "^[A-Z0-9]{32}$" }
+  }
+}
+
+validator = JSONSchema.validator_for(schema, mask: "[REDACTED]")
+
+begin
+  validator.validate!({ "password" => "123", "api_key" => "secret_key_123" })
+rescue JSONSchema::ValidationError => exc
+  puts exc.message
+  # => '[REDACTED] does not match "^[A-Z0-9]{32}$"'
+  puts exc.verbose_message
+  # => '[REDACTED] does not match "^[A-Z0-9]{32}$"\n\nFailed validating...\nOn instance["api_key"]:\n    [REDACTED]'
+end
+```
+
+### Exception Classes
+
+- **`JSONSchema::ValidationError`** - raised on validation failure
+  - `message`, `verbose_message`, `instance_path`, `schema_path`, `evaluation_path`, `kind`, `instance`
+  - JSON Pointer helpers: `instance_path_pointer`, `schema_path_pointer`, `evaluation_path_pointer`
+- **`JSONSchema::ReferencingError`** - raised when `$ref` cannot be resolved
+
+## Options Reference
+
+One-off validation methods (`valid?`, `validate!`, `each_error`, `evaluate`) accept these keyword arguments:
+
+```ruby
+JSONSchema.valid?(schema, instance,
+  draft: :draft7,                  # Specific draft version (symbol)
+  validate_formats: true,          # Enable format validation (default: false)
+  ignore_unknown_formats: true,    # Don't error on unknown formats (default: true)
+  base_uri: "https://example.com", # Base URI for reference resolution
+  mask: "[REDACTED]",              # Mask sensitive data in error messages
+  retriever: ->(uri) { ... },      # Custom schema retriever for $ref
+  formats: { "name" => proc },     # Custom format validators
+  keywords: { "name" => Klass },   # Custom keyword validators
+  registry: registry,              # Pre-registered schemas
+  pattern_options: opts,           # RegexOptions or FancyRegexOptions
+  email_options: opts,             # EmailOptions
+  http_options: opts               # HttpOptions
+)
+```
+
+`evaluate` accepts the same options except `mask` (currently unsupported for evaluation output).
+
+`validator_for` accepts the same options except `draft:` — use draft-specific validators (`Draft7Validator.new`, etc.) to pin a draft version.
+
+Valid draft symbols: `:draft4`, `:draft6`, `:draft7`, `:draft201909`, `:draft202012`.
+
+## Performance
+
+`jsonschema` is designed for high performance, outperforming other Ruby JSON Schema validators in most scenarios:
+
+- **26-141x** faster than `json_schemer` for complex schemas and large instances
+- **174-535x** faster than `json-schema` where supported
+- **7-125x** faster than `rj_schema` (RapidJSON/C++)
+
+For detailed benchmarks, see our [full performance comparison](https://github.com/Stranger6667/jsonschema/blob/master/crates/jsonschema-rb/BENCHMARKS.md).
+
+**Tips:** Reuse validators. Use `valid?` for boolean checks (short-circuits on first error).
+
+## Acknowledgements
+
+This library draws API design inspiration from the Python [`jsonschema`](https://github.com/python-jsonschema/jsonschema) package. We're grateful to the Python `jsonschema` maintainers and contributors for their pioneering work in JSON Schema validation.
+
+## Support
+
+If you have questions, need help, or want to suggest improvements, please use [GitHub Discussions](https://github.com/Stranger6667/jsonschema/discussions).
+
+## Sponsorship
+
+If you find `jsonschema` useful, please consider [sponsoring its development](https://github.com/sponsors/Stranger6667).
+
+## Contributing
+
+See [CONTRIBUTING.md](https://github.com/Stranger6667/jsonschema/blob/master/CONTRIBUTING.md) for details.
+
+## License
+
+Licensed under [MIT License](https://github.com/Stranger6667/jsonschema/blob/master/LICENSE).

data/ext/jsonschema/extconf.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require "mkmf"
+require "rb_sys/mkmf"
+
+create_rust_makefile("jsonschema/jsonschema_rb") do |r|
+  r.auto_install_rust_toolchain = false
+
+  musl_target =
+    ENV["CARGO_BUILD_TARGET"]&.include?("musl") ||
+    File.exist?("/etc/alpine-release") ||
+    begin
+      `ldd --version 2>&1` =~ /musl/
+    rescue StandardError
+      false
+    end ||
+    `rustc -vV 2>/dev/null`[/host: (.+)/, 1]&.include?("musl")
+
+  if musl_target
+    # Disable static CRT on musl.
+    r.extra_rustflags = ["-C", "target-feature=-crt-static"]
+  end
+end

data/lib/jsonschema/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module JSONSchema
+  VERSION = "0.42.0"
+end

data/lib/jsonschema_rs.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require_relative "jsonschema/version"
+
+begin
+  RUBY_VERSION =~ /(\d+\.\d+)/
+  require "jsonschema/#{Regexp.last_match(1)}/jsonschema_rb"
+rescue LoadError
+  require "jsonschema/jsonschema_rb"
+end

data/sig/jsonschema.rbs

@@ -0,0 +1,385 @@
+# Type definitions for jsonschema gem
+# High-performance JSON Schema validation for Ruby
+
+module JSONSchema
+  VERSION: String
+
+  # Valid draft version symbols
+  type draft = :draft4 | :draft6 | :draft7 | :draft201909 | :draft202012
+
+  # Create a validator with auto-detected draft version.
+  #
+  # @param schema The JSON Schema (Hash or JSON string)
+  # @param validate_formats Enable format validation
+  # @param ignore_unknown_formats Ignore unknown formats
+  # @param base_uri Base URI for reference resolution
+  # @param retriever Custom schema retriever proc
+  # @param mask Mask sensitive data in error messages
+  # @param formats Custom format validators (Hash of format_name => proc)
+  # @param keywords Custom keyword validators (Hash of keyword_name => class)
+  def self.validator_for: (
+    untyped schema,
+    ?validate_formats: bool?,
+    ?ignore_unknown_formats: bool?,
+    ?base_uri: String?,
+    ?retriever: (^(String) -> untyped)?,
+    ?mask: String?,
+    ?formats: Hash[String, ^(String) -> bool]?,
+    ?keywords: Hash[String, Class]?,
+    ?registry: Registry?,
+    ?pattern_options: (RegexOptions | FancyRegexOptions)?,
+    ?email_options: EmailOptions?,
+    ?http_options: HttpOptions?
+  ) -> Validator
+
+  # One-off validation returning boolean.
+  def self.valid?: (
+    untyped schema,
+    untyped instance,
+    ?draft: draft?,
+    ?validate_formats: bool?,
+    ?ignore_unknown_formats: bool?,
+    ?base_uri: String?,
+    ?retriever: (^(String) -> untyped)?,
+    ?mask: String?,
+    ?formats: Hash[String, ^(String) -> bool]?,
+    ?keywords: Hash[String, Class]?,
+    ?registry: Registry?,
+    ?pattern_options: (RegexOptions | FancyRegexOptions)?,
+    ?email_options: EmailOptions?,
+    ?http_options: HttpOptions?
+  ) -> bool
+
+  # One-off validation raising on error.
+  def self.validate!: (
+    untyped schema,
+    untyped instance,
+    ?draft: draft?,
+    ?validate_formats: bool?,
+    ?ignore_unknown_formats: bool?,
+    ?base_uri: String?,
+    ?retriever: (^(String) -> untyped)?,
+    ?mask: String?,
+    ?formats: Hash[String, ^(String) -> bool]?,
+    ?keywords: Hash[String, Class]?,
+    ?registry: Registry?,
+    ?pattern_options: (RegexOptions | FancyRegexOptions)?,
+    ?email_options: EmailOptions?,
+    ?http_options: HttpOptions?
+  ) -> nil
+
+  # Iterate validation errors. Returns Array when no block given, nil when block given.
+  def self.each_error: (
+    untyped schema,
+    untyped instance,
+    ?draft: draft?,
+    ?validate_formats: bool?,
+    ?ignore_unknown_formats: bool?,
+    ?base_uri: String?,
+    ?retriever: (^(String) -> untyped)?,
+    ?mask: String?,
+    ?formats: Hash[String, ^(String) -> bool]?,
+    ?keywords: Hash[String, Class]?,
+    ?registry: Registry?,
+    ?pattern_options: (RegexOptions | FancyRegexOptions)?,
+    ?email_options: EmailOptions?,
+    ?http_options: HttpOptions?
+  ) -> Array[ValidationError]
+                      | (
+    untyped schema,
+    untyped instance,
+    ?draft: draft?,
+    ?validate_formats: bool?,
+    ?ignore_unknown_formats: bool?,
+    ?base_uri: String?,
+    ?retriever: (^(String) -> untyped)?,
+    ?mask: String?,
+    ?formats: Hash[String, ^(String) -> bool]?,
+    ?keywords: Hash[String, Class]?,
+    ?registry: Registry?,
+    ?pattern_options: (RegexOptions | FancyRegexOptions)?,
+    ?email_options: EmailOptions?,
+    ?http_options: HttpOptions?
+  ) { (ValidationError) -> void } -> nil
+
+  # One-off evaluation returning structured output.
+  def self.evaluate: (
+    untyped schema,
+    untyped instance,
+    ?draft: draft?,
+    ?validate_formats: bool?,
+    ?ignore_unknown_formats: bool?,
+    ?base_uri: String?,
+    ?retriever: (^(String) -> untyped)?,
+    ?formats: Hash[String, ^(String) -> bool]?,
+    ?keywords: Hash[String, Class]?,
+    ?registry: Registry?,
+    ?pattern_options: (RegexOptions | FancyRegexOptions)?,
+    ?email_options: EmailOptions?,
+    ?http_options: HttpOptions?
+  ) -> Evaluation
+
+  # Reusable JSON Schema validator.
+  private
+  class Validator
+    # Fast validation returning boolean.
+    def valid?: (untyped instance) -> bool
+
+    # Validate and raise on first error.
+    def validate!: (untyped instance) -> nil
+
+    # Iterate validation errors. Returns Array when no block given, nil when block given.
+    def each_error: (untyped instance) -> Array[ValidationError]
+                  | (untyped instance) { (ValidationError) -> void } -> nil
+
+    # Evaluate instance and return structured output.
+    def evaluate: (untyped instance) -> Evaluation
+
+    def inspect: () -> String
+  end
+  public
+
+  # JSON Schema Draft 4 validator.
+  class Draft4Validator < Validator
+  end
+
+  # JSON Schema Draft 6 validator.
+  class Draft6Validator < Validator
+  end
+
+  # JSON Schema Draft 7 validator.
+  class Draft7Validator < Validator
+  end
+
+  # JSON Schema Draft 2019-09 validator.
+  class Draft201909Validator < Validator
+  end
+
+  # JSON Schema Draft 2020-12 validator.
+  class Draft202012Validator < Validator
+  end
+
+  # Validation error with detailed information.
+  class ValidationError < StandardError
+    # Brief error message.
+    attr_reader message: String
+
+    # Detailed error message with full context.
+    attr_reader verbose_message: String
+
+    # Path to the failing instance location.
+    attr_reader instance_path: Array[String | Integer]
+
+    # Path to the failing schema location.
+    attr_reader schema_path: Array[String | Integer]
+
+    # Evaluation path.
+    attr_reader evaluation_path: Array[String | Integer]
+
+    # The specific kind of validation error.
+    attr_reader kind: ValidationErrorKind
+
+    # The failing instance value.
+    attr_reader instance: untyped
+
+    def initialize: (
+      message: String,
+      ?verbose_message: String?,
+      ?instance_path: Array[String | Integer],
+      ?schema_path: Array[String | Integer],
+      ?evaluation_path: Array[String | Integer],
+      ?kind: ValidationErrorKind?,
+      ?instance: untyped
+    ) -> void
+
+    def to_s: () -> String
+    def inspect: () -> String
+
+    # Compare two validation errors by message, schema_path, and instance_path.
+    def ==: (untyped other) -> bool
+    alias eql? ==
+
+    # Hash code based on message, schema_path, and instance_path.
+    def hash: () -> Integer
+
+    # Convert instance_path to JSON Pointer format (RFC 6901).
+    def instance_path_pointer: () -> String
+
+    # Convert schema_path to JSON Pointer format (RFC 6901).
+    def schema_path_pointer: () -> String
+
+    # Evaluation path as JSON Pointer string (RFC 6901), pre-computed in Rust.
+    def evaluation_path_pointer: () -> String
+  end
+
+  # Type of validation error with contextual data.
+  class ValidationErrorKind
+    # Keyword name that caused the error (e.g., "type", "required", "format").
+    def name: () -> String
+
+    # Associated value for the error (varies by error type).
+    def value: () -> untyped
+
+    # Convert to hash representation.
+    def to_h: () -> Hash[Symbol, untyped]
+
+    def inspect: () -> String
+    def to_s: () -> String
+  end
+
+  # Structured evaluation output following JSON Schema specification.
+  class Evaluation
+    # Whether the instance is valid.
+    def valid?: () -> bool
+
+    # Flag output format (simplest).
+    # Returns { valid: true/false }
+    def flag: () -> Hash[Symbol, untyped]
+
+    # List output format (flat).
+    # Contains { valid: bool, details: [...] }
+    def list: () -> Hash[Symbol, untyped]
+
+    # Hierarchical output format (nested).
+    # Contains nested structure following schema hierarchy
+    def hierarchical: () -> Hash[Symbol, untyped]
+
+    # Collected annotations from all evaluated nodes.
+    # Each entry contains schemaLocation, instanceLocation, and annotations
+    def annotations: () -> Array[Hash[Symbol, untyped]]
+
+    # Collected errors from all evaluated nodes.
+    # Each entry contains schemaLocation, instanceLocation, error, and absoluteKeywordLocation
+    def errors: () -> Array[Hash[Symbol, untyped]]
+
+    def inspect: () -> String
+  end
+
+  # Schema registry for reference resolution.
+  class Registry
+    # Create a registry from URI/schema pairs.
+    # @param resources Array of [uri, schema] pairs
+    # @param draft Optional draft version constant
+    # @param retriever Custom schema retriever proc for dynamic resolution
+    def initialize: (Array[[String, untyped]] resources, ?draft: draft?, ?retriever: (^(String) -> untyped)?) -> void
+
+    def inspect: () -> String
+  end
+
+  # Raised when a reference cannot be resolved.
+  class ReferencingError < StandardError
+    attr_reader message: String
+    def initialize: (String message) -> void
+  end
+
+  # Meta-schema validation.
+  module Meta
+    # Validate a schema against its meta-schema.
+    def self.valid?: (untyped schema, ?registry: Registry?) -> bool
+
+    # Validate a schema and raise on error.
+    def self.validate!: (untyped schema, ?registry: Registry?) -> nil
+  end
+
+  # Email format validation options.
+  class EmailOptions
+    # Create email validation options.
+    # @param require_tld Require top-level domain (default: false)
+    # @param allow_domain_literal Allow domain literals like [127.0.0.1] (default: true)
+    # @param allow_display_text Allow display names like "Name <email>" (default: true)
+    # @param minimum_sub_domains Minimum number of subdomains required (default: nil)
+    def initialize: (
+      ?require_tld: bool?,
+      ?allow_domain_literal: bool?,
+      ?allow_display_text: bool?,
+      ?minimum_sub_domains: Integer?
+    ) -> void
+
+    # Whether TLD is required.
+    def require_tld: () -> bool
+
+    # Whether domain literals are allowed.
+    def allow_domain_literal: () -> bool
+
+    # Whether display text is allowed.
+    def allow_display_text: () -> bool
+
+    # Minimum number of subdomains.
+    def minimum_sub_domains: () -> Integer?
+
+    def inspect: () -> String
+    def to_s: () -> String
+  end
+
+  # Regex engine options.
+  class RegexOptions
+    # Create regex engine options.
+    # @param size_limit Maximum compiled regex size in bytes
+    # @param dfa_size_limit Maximum DFA size in bytes
+    def initialize: (?size_limit: Integer?, ?dfa_size_limit: Integer?) -> void
+
+    # Maximum compiled regex size.
+    def size_limit: () -> Integer?
+
+    # Maximum DFA size.
+    def dfa_size_limit: () -> Integer?
+
+    def inspect: () -> String
+    def to_s: () -> String
+  end
+
+  # Fancy regex engine options (ECMA-262 patterns).
+  class FancyRegexOptions
+    # Create fancy regex engine options.
+    # @param backtrack_limit Maximum backtracking steps
+    # @param size_limit Maximum compiled regex size
+    # @param dfa_size_limit Maximum DFA size
+    def initialize: (
+      ?backtrack_limit: Integer?,
+      ?size_limit: Integer?,
+      ?dfa_size_limit: Integer?
+    ) -> void
+
+    # Maximum backtracking steps.
+    def backtrack_limit: () -> Integer?
+
+    # Maximum compiled regex size.
+    def size_limit: () -> Integer?
+
+    # Maximum DFA size.
+    def dfa_size_limit: () -> Integer?
+
+    def inspect: () -> String
+    def to_s: () -> String
+  end
+
+  # HTTP client options for remote schema retrieval.
+  class HttpOptions
+    # Create HTTP client options.
+    # @param timeout Request timeout in seconds
+    # @param connect_timeout Connection timeout in seconds
+    # @param tls_verify Verify TLS certificates (default: true)
+    # @param ca_cert Path to CA certificate file
+    def initialize: (
+      ?timeout: Float?,
+      ?connect_timeout: Float?,
+      ?tls_verify: bool?,
+      ?ca_cert: String?
+    ) -> void
+
+    # Request timeout in seconds.
+    def timeout: () -> Float?
+
+    # Connection timeout in seconds.
+    def connect_timeout: () -> Float?
+
+    # Whether to verify TLS certificates.
+    def tls_verify: () -> bool
+
+    # Path to CA certificate file.
+    def ca_cert: () -> String?
+
+    def inspect: () -> String
+    def to_s: () -> String
+  end
+end

metadata

@@ -0,0 +1,86 @@
+--- !ruby/object:Gem::Specification
+name: jsonschema_rs
+version: !ruby/object:Gem::Version
+  version: 0.42.0
+platform: aarch64-linux
+authors:
+- Dmitry Dygalo
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2026-02-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bigdecimal
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.1'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.1'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '5'
+description: High-performance JSON Schema validator with support for Draft 4, 6, 7,
+  2019-09, and 2020-12.
+email:
+- dmitry@dygalo.dev
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE
+- MIGRATION.md
+- README.md
+- ext/jsonschema/extconf.rb
+- lib/jsonschema/3.2/jsonschema_rb.so
+- lib/jsonschema/3.3/jsonschema_rb.so
+- lib/jsonschema/3.4/jsonschema_rb.so
+- lib/jsonschema/4.0/jsonschema_rb.so
+- lib/jsonschema/version.rb
+- lib/jsonschema_rs.rb
+- sig/jsonschema.rbs
+homepage: https://github.com/Stranger6667/jsonschema/tree/master/crates/jsonschema-rb
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/Stranger6667/jsonschema/tree/master/crates/jsonschema-rb
+  source_code_uri: https://github.com/Stranger6667/jsonschema
+  changelog_uri: https://github.com/Stranger6667/jsonschema/blob/master/crates/jsonschema-rb/CHANGELOG.md
+  documentation_uri: https://github.com/Stranger6667/jsonschema/tree/master/crates/jsonschema-rb#readme
+  bug_tracker_uri: https://github.com/Stranger6667/jsonschema/issues
+  funding_uri: https://github.com/sponsors/Stranger6667
+  rubygems_mfa_required: 'true'
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.2'
+  - - "<"
+    - !ruby/object:Gem::Version
+      version: 4.1.dev
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.3.11
+requirements: []
+rubygems_version: 3.5.23
+signing_key: 
+specification_version: 4
+summary: A high-performance JSON Schema validator for Ruby
+test_files: []