rusty_json_schema 0.1.0 → 0.6.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e89b25e8e45ded120281d3b9b6af8a85bf5b8d0cb4f86b2f339485d629cf4dfd
-  data.tar.gz: 1c6859709cd625af4184235dc09b1dfdaf05b8d0aca6fe8998c13c8bc11c1c4b
+  metadata.gz: '0898afb3388ad9f5ff7ac27fedc0bbde902f802b23a71ae4c67cd42eb6a93ab5'
+  data.tar.gz: '073396f70a8b35c1670b13330479dccde247cd7dd66d6d8e9482ce0e46bb60c1'
 SHA512:
-  metadata.gz: 27da18c9402b2f91c92a75f97f31ad0eb9761aa322634e79ac4dd4b735bdb1d9e138821991a41c03648be01cc8ec1f15a13868cf96f65421b1d6a00f2bac226f
-  data.tar.gz: c09eaf66fce3eb9daa15c9ab78a23fa82276a7aeb2176ca23579936ff6bf798e7990731937662fc63c0d42ce7a6c59c45efbc4a5509722c84b3be16d1b3a481b
+  metadata.gz: b382459eca3e4f31a77ccb4c5e9dce4d15c5f24497955299c10f1c191df079098173d7687855d8cc11c393ecc62b87a78b01f225d9ac2def2440b2c1baf2eb05
+  data.tar.gz: 71a88a2751f3db9e05fc1a3c90240d8ac63ff51b3878f1ee2db7d7a42f9d87415935f8f2f5d1b8b69927a17bf3dad2d799fa90e740653ad135f42d6858b89678

data/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "json_schema"
-version = "0.1.0"
+version = "0.6.1"
 authors = ["Leszek Zalewski <leszekzalewski@fastmail.fm>"]
 edition = "2018"
 
@@ -9,5 +9,6 @@ name = "json_schema"
 crate-type = ["cdylib"]
 
 [dependencies]
-jsonschema = "0.4.3"
+libc = "0.2.81"
+jsonschema = "0.6.1"
 serde_json = "1.0"

data/README.md

@@ -1,11 +1,15 @@
 # RustyJSONSchema
 
-FFI wrapper around [`jsonschema`](https://github.com/Stranger6667/jsonschema-rs) rust library. Props go to original project.
+[![Gem Version](https://badge.fury.io/rb/rusty_json_schema.svg)](https://badge.fury.io/rb/rusty_json_schema)
+
+FFI wrapper around [`jsonschema`](https://github.com/Stranger6667/jsonschema-rs) Rust library. Props go to original project.
 
 Currently during heavy development.
 
 ## Installation
 
+> **NOTE**: Compilation requires openssl-dev / openssl-devel package
+
 Add this line to your application's Gemfile:
 
 ```ruby
@@ -14,11 +18,15 @@ gem "rusty_json_schema"
 
 And then execute:
 
-    $ bundle install
+```
+$ bundle install
+```
 
 Or install it yourself as:
 
-    $ gem install rusty_json_schema
+```
+$ gem install rusty_json_schema
+```
 
 ## Usage
 
@@ -32,13 +40,28 @@ Validate events like
 
 ```ruby
 validator.valid?(event_json)
+# => true/false
+```
+
+To get validation errors
+
+```ruby
+validator.validate(event_json)
+# => ["invalid...", ...]
 ```
 
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
 
-To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+To install this gem onto your local machine, run `bundle exec rake install`.
+
+To release a new version:
+
+- update version number in `version.rb` & `CHANGELOG.md`
+- create GitHub release with tag being new version prefixed with `v`, i.e. for `VERSION="0.1.0"` it would be `v0.1.0`
+- pull `*.gem` artifact from release build
+- `gem push *.gem` in order to publish it in [rubygems.org](https://rubygems.org).
 
 ## Contributing
 

data/ext/Rakefile

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require "thermite/tasks"
+require_relative "../lib/tasks/thermite_dir_patch"
+
+project_dir = File.dirname(File.dirname(__FILE__))
+thermite    = Thermite::Tasks.new(cargo_project_path: project_dir,
+                                  ruby_project_path: project_dir,
+                                  optional_rust_extension: true)
+
+namespace :thermite do # rubocop:disable Metrics/BlockLength
+  desc "Clean up default binaries"
+  task :clean_binnaries do
+    puts "Cleaning up"
+    Dir["#{thermite.config.ruby_extension_path}.*.default"].each do |file|
+      FileUtils.rm(file)
+    end
+  end
+
+  desc "Try to build extension if cargo is available or setup default lib"
+  task :build_or_default do
+    platform = "#{Gem::Platform.local.cpu}-#{Gem::Platform.local.os}"
+    default_ext_path = "#{thermite.config.ruby_extension_path}.#{platform}.default"
+
+    if thermite.cargo
+      profile = ENV.fetch("CARGO_PROFILE", "release")
+      thermite.run_cargo_rustc(profile)
+
+      FileUtils.cp(thermite.config.cargo_target_path(profile, thermite.config.cargo_shared_library),
+                   thermite.config.ruby_extension_path)
+    elsif File.exist?(default_ext_path)
+      puts "NOTE: Defaults to pre-build binary #{default_ext_path.inspect} => your mileage may vary."
+
+      FileUtils.mv(default_ext_path,
+                   thermite.config.ruby_extension_path)
+
+      thermite.inform_user_about_cargo
+    else
+      # Prebuild binary is not available for a given platform, install cargo to
+      # compile the gem
+      raise thermite.cargo_required_msg
+    end
+  end
+
+  desc "Cleanup cargo artifacts"
+  task :cargo_clean do
+    thermite.run_cargo_if_exists "clean", *thermite.cargo_manifest_path_args
+  end
+end
+
+task default: %w[thermite:build_or_default thermite:cargo_clean thermite:clean_binnaries]

data/lib/rusty_json_schema.rb

@@ -1,62 +1,49 @@
 # frozen_string_literal: true
 
 require "ffi"
+require "json"
 
-require_relative "rusty_json_schema/version"
+require "rusty_json_schema/version"
+require "rusty_json_schema/nodes_array"
+require "rusty_json_schema/validator"
+require "rusty_json_schema/binding"
 
 # JSON Schema validation
 #
 # ## Example
 #
-#     validator = RustyJSONSchema.build(schema) # where schema is a json string of the schema
-#     validator.valid?(event) # where event is a json string of schema
+#     validator = RustyJSONSchema.build(schema)
+#
+#     validator.valid?(event)
 #     # => true/false
 #
+#     validator.validate(event)
+#     # => [] / ["...error messages", ...]
+#
 module RustyJSONSchema
 
-  def self.build(schema)
-    RustyJSONSchema::Validator::Binding.new(schema)
-  end
-
   class Error < StandardError; end
 
-  # Handles release of the pointer automatically
-  # with Ruby GC. This way we can intialize validator
-  # in Rust, and hold a reference in Ruby.
-  #
-  class Validator < FFI::AutoPointer
+  class << self
 
-    # Custom GC flow for our validator, freeing
-    # the object within Rust
-    #
-    def self.release(pointer)
-      Binding.free(pointer)
+    attr_writer :processor
+
+    def processor
+      @processor ||= JSON
     end
 
-    # Simple validation without actual error messages
-    #
-    def valid?(event)
-      Binding.is_valid(self, event)
+    def dump(data)
+      case data
+      when String then data
+      else processor.dump(data)
+      end
     end
 
-    # FFI container for our library.
+    # Helper method that returns new instance of pointer
+    # to Validator struct.
     #
-    module Binding
-
-      extend FFI::Library
-
-      lib_name =
-        case ::FFI::Platform::LIBSUFFIX
-        when "so", "dylib" then "libjson_schema"
-        when "dll" then "json_schema"
-        end
-
-      ffi_lib File.expand_path("ext/#{lib_name}.#{::FFI::Platform::LIBSUFFIX}", __dir__)
-
-      attach_function :new, :validator_new, [:string], Validator
-      attach_function :free, :validator_free, [Validator], :void
-      attach_function :is_valid, :validator_is_valid, [Validator, :string], :bool
-
+    def build(schema)
+      RustyJSONSchema::Binding.new(dump(schema))
     end
 
   end

data/lib/rusty_json_schema/binding.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module RustyJSONSchema
+
+  # Integration point between Rust jsonschema wrapper
+  # and RustyJSONSchema.
+  #
+  module Binding
+
+    extend FFI::Library
+
+    ffi_lib File.expand_path("../../ext/json_schema.so", __dir__)
+
+    attach_function :new, :validator_new, [:string], Validator
+    attach_function :free, :validator_free, [Validator], :void
+    attach_function :free_array, :array_free, [NodesArray], :void
+    attach_function :is_valid, :validator_is_valid, [Validator, :string], :bool
+    attach_function :validate, :validator_validate, [Validator, :string], NodesArray.by_ref
+
+  end
+
+end

data/lib/rusty_json_schema/nodes_array.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module RustyJSONSchema
+
+  # Struct representing list of errors returned from
+  # our wrapper library. Use ManagedStruct in order to
+  # properly release nested strings which would otherwise
+  # leak and pollute the memory.
+  #
+  class NodesArray < FFI::ManagedStruct
+
+    layout :data, :pointer,
+           :len,  :uint,
+           :cap,  :uint
+
+    def to_a
+      self[:data].get_array_of_string(0, self[:len]).compact
+    end
+
+    def self.release(ptr)
+      Binding.free_array(ptr)
+    end
+
+  end
+
+end

data/lib/rusty_json_schema/validator.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module RustyJSONSchema
+
+  # Handles release of the pointer automatically
+  # with Ruby GC. This way we can intialize validator
+  # in Rust, and hold a reference in Ruby.
+  #
+  class Validator < FFI::AutoPointer
+
+    # Custom GC flow for our validator, freeing
+    # the object within Rust
+    #
+    def self.release(pointer)
+      Binding.free(pointer)
+    end
+
+    # Simple validation without actual error messages
+    #
+    def valid?(event)
+      Binding.is_valid(self, RustyJSONSchema.dump(event))
+    end
+
+    def validate(event)
+      Binding.validate(self, RustyJSONSchema.dump(event)).to_a
+    end
+
+  end
+
+end

data/lib/rusty_json_schema/version.rb

@@ -2,6 +2,6 @@
 
 module RustyJSONSchema
 
-  VERSION = "0.1.0"
+  VERSION = "0.6.1"
 
 end

data/lib/tasks/thermite_dir_patch.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+# Update where this option is configurable
+# is not yet released
+module ThermiteDirPatch
+
+  def ruby_extension_path
+    ruby_path("ext", shared_library)
+  end
+
+end
+
+Thermite::Config.prepend(ThermiteDirPatch)

data/rusty_json_schema.gemspec

@@ -2,7 +2,7 @@
 
 require_relative "lib/rusty_json_schema/version"
 
-Gem::Specification.new do |spec|
+Gem::Specification.new do |spec| # rubocop:disable Metrics/BlockLength
   spec.name        = "rusty_json_schema"
   spec.version     = RustyJSONSchema::VERSION
   spec.authors     = ["Leszek Zalewski"]
@@ -16,17 +16,30 @@ Gem::Specification.new do |spec|
     Currently during heavy development.
   STR
 
-  spec.required_ruby_version = Gem::Requirement.new(">= 2.5.0")
+  spec.required_ruby_version = Gem::Requirement.new(">= 2.6.0")
 
   spec.metadata["allowed_push_host"] = "https://rubygems.org"
   spec.metadata["homepage_uri"]      = spec.homepage
   spec.metadata["source_code_uri"]   = spec.homepage
   spec.metadata["changelog_uri"]     = "https://github.com/driv3r/rusty_json_schema/blob/main/CHANGELOG.md"
 
-  spec.files = Dir["lib/**/*", "src/**/*.rs", "rusty_json_schema.gemspec", "Cargo.toml", "LICENSE", "README.md"]
+  spec.files = Dir[
+    "lib/**/*",
+    "src/**/*.rs",
+    "rusty_json_schema.gemspec",
+    "Cargo.toml",
+    "LICENSE",
+    "README.md",
+    "ext/Rakefile",
+    "ext/*.default"
+  ]
 
   spec.require_paths = ["lib"]
 
+  spec.extensions << "ext/Rakefile"
+  spec.add_runtime_dependency "thermite", "~> 0"
+
   # Uncomment to register a new dependency of your gem
   spec.add_dependency "ffi", "~> 1.14"
+  spec.add_dependency "json", ">= 1.0"
 end

data/src/lib.rs

@@ -1,8 +1,10 @@
+extern crate libc;
+
 use jsonschema::JSONSchema;
 use serde_json::Value;
 
-use std::ffi::CStr;
-use std::os::raw::c_char;
+use std::ffi::{CStr, CString};
+use std::os::raw::{c_char, c_uint};
 
 /*
  * Our wrapper struct for schema and schema value,
@@ -22,7 +24,8 @@ impl Validator {
      */
     fn new(schema: Value) -> Validator {
         let boxed_schema: &'static Value = Box::leak(Box::new(schema));
-        let boxed_compile: &'static JSONSchema<'static> = Box::leak(Box::new(JSONSchema::compile(boxed_schema).unwrap()));
+        let boxed_compile: &'static JSONSchema<'static> =
+            Box::leak(Box::new(JSONSchema::compile(boxed_schema).unwrap()));
 
         Validator {
             schema: boxed_compile,
@@ -33,6 +36,18 @@ impl Validator {
     fn is_valid(&self, event: &Value) -> bool {
         self.schema.is_valid(event)
     }
+
+    fn validate(&self, event: &Value) -> Vec<String> {
+        let mut errors: Vec<String> = vec![];
+
+        if let Err(validation_errors) = self.schema.validate(event) {
+            for error in validation_errors {
+                errors.push(error.to_string());
+            }
+        }
+
+        errors
+    }
 }
 
 impl Drop for Validator {
@@ -48,6 +63,36 @@ impl Drop for Validator {
     }
 }
 
+#[repr(C)]
+pub struct Array {
+    data: *mut *mut c_char,
+    len: c_uint,
+    cap: c_uint,
+}
+
+impl Array {
+    fn from_vec(from: Vec<String>) -> Self {
+        let mut converted: Vec<*mut c_char> = from
+            .into_iter()
+            .map(|s| CString::new(s).unwrap().into_raw())
+            .collect();
+
+        converted.shrink_to_fit();
+
+        let len = converted.len();
+        let cap = converted.capacity();
+        let result = Array {
+            data: converted.as_mut_ptr(),
+            len: len as c_uint,
+            cap: cap as c_uint,
+        };
+
+        std::mem::forget(converted);
+
+        result
+    }
+}
+
 fn to_string(ptr: *const c_char) -> &'static CStr {
     unsafe {
         assert!(!ptr.is_null());
@@ -57,7 +102,7 @@ fn to_string(ptr: *const c_char) -> &'static CStr {
 
 #[no_mangle]
 pub extern "C" fn validator_new(c_schema: *const c_char) -> *mut Validator {
-    let raw_schema  = to_string(c_schema);
+    let raw_schema = to_string(c_schema);
     let schema = serde_json::from_slice(raw_schema.to_bytes()).unwrap();
     let validator = Validator::new(schema);
 
@@ -65,6 +110,7 @@ pub extern "C" fn validator_new(c_schema: *const c_char) -> *mut Validator {
 }
 
 #[no_mangle]
+#[allow(clippy::not_unsafe_ptr_arg_deref)]
 pub extern "C" fn validator_free(ptr: *mut Validator) {
     if ptr.is_null() {
         return;
@@ -76,6 +122,7 @@ pub extern "C" fn validator_free(ptr: *mut Validator) {
 }
 
 #[no_mangle]
+#[allow(clippy::not_unsafe_ptr_arg_deref)]
 pub extern "C" fn validator_is_valid(ptr: *const Validator, event: *const c_char) -> bool {
     let validator = unsafe {
         assert!(!ptr.is_null());
@@ -88,31 +135,134 @@ pub extern "C" fn validator_is_valid(ptr: *const Validator, event: *const c_char
     validator.is_valid(&event)
 }
 
+#[no_mangle]
+#[allow(clippy::not_unsafe_ptr_arg_deref)]
+pub extern "C" fn validator_validate(ptr: *const Validator, event: *const c_char) -> *mut Array {
+    let validator = unsafe {
+        assert!(!ptr.is_null());
+        &*ptr
+    };
+
+    let raw_event = to_string(event);
+    let event: Value = serde_json::from_slice(raw_event.to_bytes()).unwrap();
+    let errors = validator.validate(&event);
+    let result = Array::from_vec(errors);
+    let boxed = Box::new(result);
+
+    Box::into_raw(boxed)
+}
+
+#[no_mangle]
+#[allow(clippy::not_unsafe_ptr_arg_deref)]
+pub extern "C" fn array_free(ptr: *mut Array) {
+    if ptr.is_null() {
+        return;
+    }
+
+    unsafe {
+        let array = Box::from_raw(ptr);
+        let data = Vec::from_raw_parts(array.data, array.len as usize, array.cap as usize);
+
+        for string in data {
+            let _ = CString::from_raw(string);
+        }
+    }
+}
+
 #[cfg(test)]
 mod tests {
     // Note this useful idiom: importing names from outer (for mod tests) scope.
     use super::*;
     use std::ffi::CString;
-    use std::{thread, time};
 
     /*
      * Simple sanity check if everything works together
      */
     #[test]
     fn test_valid_event() {
-        let schema = CString::new("{\"$schema\":\"http://json-schema.org/draft-07/schema#\",\"type\":\"array\",\"items\":[{\"type\":\"number\",\"exclusiveMaximum\":10}]}").unwrap();
-        let valid_event = CString::new("[9]").unwrap();
-        let invalid_event = CString::new("[22]").unwrap();
+        let validator = validator_new(helper_c_schema().as_ptr());
+
+        assert!(validator_is_valid(validator, helper_c_valid().as_ptr()));
+
+        assert!(!validator_is_valid(validator, helper_c_invalid().as_ptr()));
+
+        validator_free(validator);
+    }
+
+    #[test]
+    fn test_validate_event_when_valid() {
+        let validator = validator_new(helper_c_schema().as_ptr());
+        let raw_result = validator_validate(validator, helper_c_valid().as_ptr());
+        let result = unsafe { helper_validate_result_as_vec(raw_result) };
+
+        let expectation: Vec<String> = vec![];
+
+        assert_eq!(result, expectation);
 
-        let c_schema_ptr: *const c_char = schema.as_ptr();
-        let c_valid_event_ptr: *const c_char = valid_event.as_ptr();
-        let c_invalid_event_ptr: *const c_char = invalid_event.as_ptr();
+        validator_free(validator);
+    }
+
+    #[test]
+    fn test_validate_event_when_invalid() {
+        let validator = validator_new(helper_c_schema().as_ptr());
+        let raw_result = validator_validate(validator, helper_c_invalid().as_ptr());
+        let result = unsafe { helper_validate_result_as_vec(raw_result) };
 
-        let validator = validator_new(c_schema_ptr);
+        let expectation: Vec<String> = vec![
+            String::from("\'\"rusty\"\' is not of type \'number\'"),
+            String::from("\'1\' is not of type \'string\'"),
+            String::from("\'baz\' is a required property"),
+        ];
 
-        assert!(validator_is_valid(validator, c_valid_event_ptr));
-        assert!(!validator_is_valid(validator, c_invalid_event_ptr));
+        assert_eq!(result, expectation);
 
         validator_free(validator);
     }
+
+    /*
+     * Test helpers
+     */
+    fn helper_c_schema() -> CString {
+        CString::new(
+            r#"{
+                "properties":{
+                    "foo": {"type": "string"},
+                    "bar": {"type": "number"},
+                    "baz": {}
+                },
+                "required": ["baz"]
+            }"#,
+        )
+        .unwrap()
+    }
+
+    fn helper_c_valid() -> CString {
+        CString::new(
+            r#"{
+                "foo": "rusty",
+                "bar": 1,
+                "baz": "rusty"
+            }"#,
+        )
+        .unwrap()
+    }
+
+    fn helper_c_invalid() -> CString {
+        CString::new(
+            r#"{
+                "foo": 1,
+                "bar": "rusty"
+            }"#,
+        )
+        .unwrap()
+    }
+
+    unsafe fn helper_validate_result_as_vec(result: *mut Array) -> Vec<String> {
+        let raw = Box::from_raw(result);
+
+        Vec::from_raw_parts(raw.data, raw.len as usize, raw.cap as usize)
+            .into_iter()
+            .map(|x| CString::from_raw(x).into_string().unwrap())
+            .collect()
+    }
 }

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: rusty_json_schema
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.6.1
 platform: ruby
 authors:
 - Leszek Zalewski
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-12-28 00:00:00.000000000 Z
+date: 2021-06-02 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: thermite
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: ffi
   requirement: !ruby/object:Gem::Requirement
@@ -24,6 +38,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.14'
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.0'
 description: |2
       FFI wrapper around https://github.com/Stranger6667/jsonschema-rs Rust library.
 
@@ -31,21 +59,22 @@ description: |2
 email:
 - leszekzalewski@fastmail.fm
 executables: []
-extensions: []
+extensions:
+- ext/Rakefile
 extra_rdoc_files: []
 files:
 - Cargo.toml
 - README.md
-- lib/ext/json_schema.d
-- lib/ext/json_schema.dll
-- lib/ext/json_schema.dll.exp
-- lib/ext/json_schema.dll.lib
-- lib/ext/json_schema.pdb
-- lib/ext/libjson_schema.d
-- lib/ext/libjson_schema.dylib
-- lib/ext/libjson_schema.so
+- ext/Rakefile
+- ext/json_schema.so.x64-mingw32.default
+- ext/json_schema.so.x86_64-darwin.default
+- ext/json_schema.so.x86_64-linux.default
 - lib/rusty_json_schema.rb
+- lib/rusty_json_schema/binding.rb
+- lib/rusty_json_schema/nodes_array.rb
+- lib/rusty_json_schema/validator.rb
 - lib/rusty_json_schema/version.rb
+- lib/tasks/thermite_dir_patch.rb
 - rusty_json_schema.gemspec
 - src/lib.rs
 homepage: https://github.com/driv3r/rusty_json_schema
@@ -64,15 +93,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.5.0
+      version: 2.6.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.3
+rubygems_version: 3.0.1
 signing_key: 
 specification_version: 4
 summary: FFI wrapper around jsonschema-rs Rust library.

data/lib/ext/json_schema.d

@@ -1 +0,0 @@
-D:\a\rusty_json_schema\rusty_json_schema\target\x86_64-pc-windows-msvc\release\json_schema.dll: D:\a\rusty_json_schema\rusty_json_schema\src\lib.rs

data/lib/ext/libjson_schema.d

@@ -1 +0,0 @@
-/home/runner/work/rusty_json_schema/rusty_json_schema/target/x86_64-unknown-linux-gnu/release/libjson_schema.so: /home/runner/work/rusty_json_schema/rusty_json_schema/src/lib.rs