rusty_json_schema 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e89b25e8e45ded120281d3b9b6af8a85bf5b8d0cb4f86b2f339485d629cf4dfd
-  data.tar.gz: 1c6859709cd625af4184235dc09b1dfdaf05b8d0aca6fe8998c13c8bc11c1c4b
+  metadata.gz: dd6b9fde168fe809a7285e76360ae1a87c55c3e0603d4e4901b76f1b4c101674
+  data.tar.gz: '08b4831a5dff32132d473d17470fc992c4b6a453472366eca4f7b511b84fea2a'
 SHA512:
-  metadata.gz: 27da18c9402b2f91c92a75f97f31ad0eb9761aa322634e79ac4dd4b735bdb1d9e138821991a41c03648be01cc8ec1f15a13868cf96f65421b1d6a00f2bac226f
-  data.tar.gz: c09eaf66fce3eb9daa15c9ab78a23fa82276a7aeb2176ca23579936ff6bf798e7990731937662fc63c0d42ce7a6c59c45efbc4a5509722c84b3be16d1b3a481b
+  metadata.gz: 7b45b35d8d14862cf402215993c2075885ad014a2c80a41394bf9959495a4ecb5993d17bb31d479260f83746325e6c1b3527dfaa630af8967a884f4413ef9f5f
+  data.tar.gz: a70e61c95d6f55d66da0848fa4edc0a78dad1fa08da140eca8c2f0af8d0365f51eff7f8ee7dfdb855ffe6de1488b0c1499b0bddf3a357a9e34e89a0c4b414404

data/Cargo.toml

@@ -9,5 +9,6 @@ name = "json_schema"
 crate-type = ["cdylib"]
 
 [dependencies]
+libc = "0.2.81"
 jsonschema = "0.4.3"
 serde_json = "1.0"

data/README.md

@@ -1,6 +1,8 @@
 # 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.
 
@@ -14,11 +16,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 +38,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/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,28 @@
+# frozen_string_literal: true
+
+module RustyJSONSchema
+
+  # Integration point between Rust jsonschema wrapper
+  # and RustyJSONSchema.
+  #
+  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 :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.2.0"
 
 end

data/rusty_json_schema.gemspec

@@ -29,4 +29,5 @@ Gem::Specification.new do |spec|
 
   # 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,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rusty_json_schema
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Leszek Zalewski
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-12-28 00:00:00.000000000 Z
+date: 2020-12-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi
@@ -24,6 +24,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.
 
@@ -45,6 +59,9 @@ files:
 - lib/ext/libjson_schema.dylib
 - lib/ext/libjson_schema.so
 - 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
 - rusty_json_schema.gemspec
 - src/lib.rs