rust_json_schema 0.3.0 → 0.5.2

data/README.md

@@ -5,7 +5,7 @@
 `rust_json_schema` is a Ruby wrapper gem for Rust's [jsonschema-rs crate](https://github.com/Stranger6667/jsonschema-rs).
 
 > [!IMPORTANT]
-> This gem is built with `json_schema` crate version `0.19.1`, and therefore does not support any features for any potential future versions of the crate. I will review and accept PRs if you would like to work on adding support for newer versions of the crate. I generally am trying to keep things up to date but I am not cutting new releases for each new patch version of the crate.
+> This gem is built with `json_schema` crate version `0.32.1`, and therefore does not support any features for any potential future versions of the crate. I will review and accept PRs if you would like to work on adding support for newer versions of the crate. I am trying to keep things up to date occasionally, but I am not regularly cutting new releases for each new version of the crate.
 
 The minimum Ruby version required by this gem is 3.0, due to the runtime Rust libraries that make the extensions possible (and easy).
 
@@ -55,7 +55,9 @@ errors = validator.validate('{ "foo": 1, "bar": "wadus" }')
 
 - `:draft` - Select the JSON schema draft number to use. Valid options are `draft4`, `draft6`, `draft7`, `draft201909`, and `draft202012`. Supported drafts are entirely determined by the `jsonschema` crate. The default draft is also determined by the crate. If new versions of the crate support additional draft versions, a code change in this gem will be required. I'm open to PRs to solve this problem - I don't know enough Rust to tell if it's easily done. _Both `draft201909` and `draft202012` are reported to have "some keywords not implemented", so use them at your own risk._
 
-Any additional options provided by the `jsonschema` crate are options I do not understand or may not make sense to implement in a wrapper library such as this.
+- `:with_base_uri` - Sets a base URI to use when resolving relative schema references during validation. Relative URIs within the schema will be evaluated relative to this base URI. This is especially useful when validating schemas loaded from sources without an inherent base URL.
+
+Any additional options provided by the `jsonschema` crate are either options I do not understand as a whole, have not figured out how to (or tried to) implement, or may not make sense to implement in a wrapper library such as this.
 
 `RustJSONSchema::Validator#options` is provided and will return a Hash containing configuration options from the underlying Rust library. While I make an effort for them to look similar, or identical, to the options passed into the `Validator` initializer, the initializer arguments and the returned Hash should not be considered one-to-one. It exists as a way to confirm the configuration of the underlying schema validator instance.
 

data/Rakefile

@@ -11,7 +11,7 @@ require "rb_sys/extensiontask"
 
 task build: :compile
 
-rubies = ["3.3.0", "3.2.0", "3.1.0", "3.0.0"]
+rubies = ["4.0.0", "3.4.0", "3.3.0", "3.2.0", "3.1.0", "3.0.0"]
 ENV["RUBY_CC_VERSION"] ||= rubies.join(":")
 
 spec = Bundler::GemHelper.gemspec

data/ext/rust_json_schema/Cargo.toml

@@ -10,7 +10,7 @@ publish = false
 crate-type = ["cdylib"]
 
 [dependencies]
-jsonschema = "0.19"
-magnus = "0.7"
+jsonschema = "0.32.1"
+magnus = "0.8"
 serde_json = "1.0"
-rb-sys = { version = "*", default-features = false, features = ["ruby-static"] }
+rb-sys = { version = "*", default-features = false }

data/ext/rust_json_schema/src/lib.rs

@@ -1,6 +1,6 @@
 extern crate serde_json;
 
-use jsonschema::{Draft, JSONSchema};
+use jsonschema::Draft;
 use magnus::{
     exception::ExceptionClass,
     function,
@@ -9,21 +9,37 @@ use magnus::{
     prelude::*,
     scan_args::{get_kwargs, scan_args},
     value::Lazy,
-    wrap, Error, RHash, RModule, Ruby, StaticSymbol, Value,
+    wrap, Error, RHash, RModule, Ruby, Value,
 };
 
 #[wrap(class = "RustJSONSchema::Validator")]
 struct Validator {
-    schema: JSONSchema,
+    schema: jsonschema::Validator,
     draft: Draft,
+    base_uri: Option<String>,
 }
 
 impl Validator {
     fn new(args: &[Value]) -> Result<Validator, Error> {
         let args = scan_args::<_, (), (), (), _, ()>(args)?;
         let (json,): (String,) = args.required;
-        let kwargs = get_kwargs::<_, (), (Option<Value>,), ()>(args.keywords, &[], &["draft"])?;
-        let (draft_arg,): (Option<Value>,) = kwargs.optional;
+
+        let value: serde_json::Value = match serde_json::from_str(&json) {
+            Ok(value) => value,
+            Err(error) => {
+                return Err(Error::new(
+                    Self::ruby().get_inner(&JSON_PARSE_ERROR),
+                    error.to_string(),
+                ))
+            }
+        };
+
+        let kwargs = get_kwargs::<_, (), (Option<Value>, Option<Value>), ()>(
+            args.keywords,
+            &[],
+            &["draft", "with_base_uri"],
+        )?;
+        let (draft_arg, with_base_uri_arg): (Option<Value>, Option<Value>) = kwargs.optional;
 
         let draft = match draft_arg {
             Some(draft) => match draft.to_string().to_lowercase().as_str() {
@@ -42,20 +58,19 @@ impl Validator {
             None => jsonschema::Draft::default(),
         };
 
-        let value: serde_json::Value = match serde_json::from_str(&json) {
-            Ok(value) => value,
-            Err(error) => {
-                return Err(Error::new(
-                    Self::ruby().get_inner(&JSON_PARSE_ERROR),
-                    error.to_string(),
-                ))
-            }
+        let options = jsonschema::options().with_draft(draft);
+
+        let base_uri = match with_base_uri_arg {
+            Some(uri) if !uri.is_nil() => Some(uri.to_string()),
+            _ => None,
         };
 
-        let mut schema = JSONSchema::options();
-        schema.with_draft(draft);
+        let options = match base_uri {
+            Some(ref uri) => options.with_base_uri(uri),
+            None => options,
+        };
 
-        let schema = match schema.compile(&value) {
+        let schema = match options.build(&value) {
             Ok(schema) => schema,
             Err(error) => {
                 return Err(Error::new(
@@ -65,7 +80,11 @@ impl Validator {
             }
         };
 
-        Ok(Validator { schema, draft })
+        Ok(Validator {
+            schema,
+            draft,
+            base_uri,
+        })
     }
 
     fn is_valid(&self, json: String) -> Result<bool, Error> {
@@ -83,16 +102,19 @@ impl Validator {
     }
 
     fn options(&self) -> Result<RHash, Error> {
-        let options = RHash::new();
+        let ruby = Self::ruby();
+        let result = ruby.hash_new();
 
-        options
-            .aset(
-                StaticSymbol::new("draft"),
-                StaticSymbol::new(format!("{:?}", self.draft).to_lowercase()),
-            )
-            .unwrap();
+        result.aset(
+            ruby.sym_new("draft"),
+            ruby.sym_new(format!("{:?}", self.draft).to_lowercase()),
+        )?;
 
-        Ok(options)
+        if let Some(uri) = &self.base_uri {
+            result.aset(ruby.sym_new("with_base_uri"), ruby.str_new(uri))?;
+        }
+
+        Ok(result)
     }
 
     fn validate(&self, json: String) -> Result<Vec<String>, Error> {
@@ -108,15 +130,13 @@ impl Validator {
 
         let mut errors: Vec<String> = vec![];
 
-        if let Err(validation_errors) = self.schema.validate(&value) {
-            for error in validation_errors {
-                let path = match format!("{}", error.instance_path).as_str() {
-                    "" => "/".to_string(),
-                    p => p.to_string(),
-                };
+        for error in self.schema.iter_errors(&value) {
+            let path = match format!("{}", error.instance_path).as_str() {
+                "" => "/".to_string(),
+                p => p.to_string(),
+            };
 
-                errors.push(format!("path \"{}\": {}", path, error));
-            }
+            errors.push(format!("path \"{}\": {}", path, error));
         }
 
         Ok(errors)

data/lib/rust_json_schema/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RustJSONSchema
-  VERSION = "0.3.0"
+  VERSION = "0.5.2"
 end

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: rust_json_schema
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.5.2
 platform: ruby
 authors:
 - Taylor Thurlow
-autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-09-16 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake-compiler
@@ -47,6 +46,7 @@ extensions:
 extra_rdoc_files: []
 files:
 - ".rspec"
+- ".ruby-version"
 - ".standard.yml"
 - Cargo.lock
 - Cargo.toml
@@ -66,7 +66,6 @@ metadata:
   homepage_uri: https://github.com/taylorthurlow/rust_json_schema-rb
   source_code_uri: https://github.com/taylorthurlow/rust_json_schema-rb
   changelog_uri: https://github.com/taylorthurlow/rust_json_schema-rb/releases
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -81,8 +80,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: 3.3.11
 requirements: []
-rubygems_version: 3.5.18
-signing_key:
+rubygems_version: 4.0.17
 specification_version: 4
 summary: Ruby wrapper for jsonschema-rs
 test_files: []