rusty_json_schema 0.3.0-x64-mingw32

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: ef776b75f005158065c0c6a7d41f89fee9abcb565f71d4268e15ddfd9f8afe67
+  data.tar.gz: 529d0e8fd559c0d103c6a451e074d41415cf06807a26990d5a545a29706acccf
+SHA512:
+  metadata.gz: fddf71983ca50ca850292390aea7d8cb9f39dfc0ffd9a4b10d122a8d31c2d407b2c1a53a9e6588511c5eecbfb690dd0443099b75cbef37bb13582bbc5e61ff8a
+  data.tar.gz: d51b14c7c352ceb284be2bb852f27d88d793f6678683ea827c2088e18e3ca356117c99d2d0e63ecce8915bc2391a1bf5349ecb48b494712b6dc40af17a7c8586

data/Cargo.toml

@@ -0,0 +1,14 @@
+[package]
+name = "json_schema"
+version = "0.3.0"
+authors = ["Leszek Zalewski <leszekzalewski@fastmail.fm>"]
+edition = "2018"
+
+[lib]
+name = "json_schema"
+crate-type = ["cdylib"]
+
+[dependencies]
+libc = "0.2.81"
+jsonschema = "0.4.3"
+serde_json = "1.0"

data/README.md

@@ -0,0 +1,74 @@
+# RustyJSONSchema
+
+[![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
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem "rusty_json_schema"
+```
+
+And then execute:
+
+```
+$ bundle install
+```
+
+Or install it yourself as:
+
+```
+$ gem install rusty_json_schema
+```
+
+## Usage
+
+Initialize schema validator
+
+```ruby
+validator = RustyJSONSchema.build(json_schema)
+```
+
+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 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
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/driv3r/rusty_json_schema. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/driv3r/rusty_json_schema/blob/master/CODE_OF_CONDUCT.md).
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+## Code of Conduct
+
+Everyone interacting in the RustyJSONSchema project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/driv3r/rusty_json_schema/blob/master/CODE_OF_CONDUCT.md).

data/ext/Rakefile

@@ -0,0 +1,36 @@
+# 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
+  desc "Try to build extension if cargo is available or setup default lib"
+  task :build_or_default do
+    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)
+    else
+      puts "NOTE: Defaults to pre-build binary => your mileage may vary."
+
+      FileUtils.mv("#{thermite.config.ruby_extension_path}.default",
+                   thermite.config.ruby_extension_path)
+
+      thermite.inform_user_about_cargo
+    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]

data/lib/rusty_json_schema.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require "ffi"
+require "json"
+
+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)
+#
+#     validator.valid?(event)
+#     # => true/false
+#
+#     validator.validate(event)
+#     # => [] / ["...error messages", ...]
+#
+module RustyJSONSchema
+
+  class Error < StandardError; end
+
+  class << self
+
+    attr_writer :processor
+
+    def processor
+      @processor ||= JSON
+    end
+
+    def dump(data)
+      case data
+      when String then data
+      else processor.dump(data)
+      end
+    end
+
+    # Helper method that returns new instance of pointer
+    # to Validator struct.
+    #
+    def build(schema)
+      RustyJSONSchema::Binding.new(dump(schema))
+    end
+
+  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

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module RustyJSONSchema
+
+  VERSION = "0.3.0"
+
+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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require_relative "lib/rusty_json_schema/version"
+
+Gem::Specification.new do |spec| # rubocop:disable Metrics/BlockLength
+  spec.name        = "rusty_json_schema"
+  spec.version     = RustyJSONSchema::VERSION
+  spec.authors     = ["Leszek Zalewski"]
+  spec.email       = ["leszekzalewski@fastmail.fm"]
+  spec.license     = "MIT"
+  spec.homepage    = "https://github.com/driv3r/rusty_json_schema"
+  spec.summary     = "FFI wrapper around jsonschema-rs Rust library."
+  spec.description = <<-STR
+    FFI wrapper around https://github.com/Stranger6667/jsonschema-rs Rust library.
+
+    Currently during heavy development.
+  STR
+
+  spec.platform              = Gem::Platform::CURRENT if ENV.key?("PER_PLATFORM_BUILD")
+  spec.required_ruby_version = Gem::Requirement.new(">= 2.5.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",
+    "ext/Rakefile",
+    "ext/json_schema.so.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

@@ -0,0 +1,268 @@
+extern crate libc;
+
+use jsonschema::JSONSchema;
+use serde_json::Value;
+
+use std::ffi::{CStr, CString};
+use std::os::raw::{c_char, c_uint};
+
+/*
+ * Our wrapper struct for schema and schema value,
+ * we need to hold onto value in order to not have
+ * it freed up, as JSONSchema uses it as reference.
+ */
+pub struct Validator {
+    schema: &'static JSONSchema<'static>,
+    schema_value: &'static Value,
+}
+
+impl Validator {
+    /*
+     * With Box::leak we avoid freeing up of schema
+     * and schema value, we free them up separately
+     * in the Drop implementation
+     */
+    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()));
+
+        Validator {
+            schema: boxed_compile,
+            schema_value: boxed_schema,
+        }
+    }
+
+    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 {
+    /*
+     * Free up schema with value by "materializing" them,
+     * otherwise they will leak memory.
+     */
+    fn drop(&mut self) {
+        unsafe {
+            Box::from_raw(self.schema as *const _ as *mut JSONSchema);
+            Box::from_raw(self.schema_value as *const _ as *mut Value);
+        }
+    }
+}
+
+#[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());
+        CStr::from_ptr(ptr)
+    }
+}
+
+#[no_mangle]
+pub extern "C" fn validator_new(c_schema: *const c_char) -> *mut Validator {
+    let raw_schema = to_string(c_schema);
+    let schema = serde_json::from_slice(raw_schema.to_bytes()).unwrap();
+    let validator = Validator::new(schema);
+
+    Box::into_raw(Box::new(validator))
+}
+
+#[no_mangle]
+#[allow(clippy::not_unsafe_ptr_arg_deref)]
+pub extern "C" fn validator_free(ptr: *mut Validator) {
+    if ptr.is_null() {
+        return;
+    }
+
+    unsafe {
+        Box::from_raw(ptr);
+    }
+}
+
+#[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());
+        &*ptr
+    };
+
+    let raw_event = to_string(event);
+    let event: Value = serde_json::from_slice(raw_event.to_bytes()).unwrap();
+
+    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;
+
+    /*
+     * Simple sanity check if everything works together
+     */
+    #[test]
+    fn test_valid_event() {
+        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);
+
+        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 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_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

@@ -0,0 +1,106 @@
+--- !ruby/object:Gem::Specification
+name: rusty_json_schema
+version: !ruby/object:Gem::Version
+  version: 0.3.0
+platform: x64-mingw32
+authors:
+- Leszek Zalewski
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2021-01-07 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
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.14'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !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.
+
+      Currently during heavy development.
+email:
+- leszekzalewski@fastmail.fm
+executables: []
+extensions:
+- ext/Rakefile
+extra_rdoc_files: []
+files:
+- Cargo.toml
+- README.md
+- ext/Rakefile
+- ext/json_schema.so.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
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/driv3r/rusty_json_schema
+  source_code_uri: https://github.com/driv3r/rusty_json_schema
+  changelog_uri: https://github.com/driv3r/rusty_json_schema/blob/main/CHANGELOG.md
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.5.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.3
+signing_key: 
+specification_version: 4
+summary: FFI wrapper around jsonschema-rs Rust library.
+test_files: []