activerecord_json_validator 1.3.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d9dce365377ebd51d3f5b8156e3cf928507014ed1278c0ca794675b4fecd3d2c
-  data.tar.gz: b1f58a7b215df70ff616dd80ee31dd24dd8fa0b0020189ee99318fb577a38621
+  metadata.gz: 0f5b518bda8ab28520f561dc840f47223e252530a9182ef31a164c12fb831451
+  data.tar.gz: 79e01fcce3c8cb0e27f6e3e24df4db54a312f6cef7285f38cec05689e897d042
 SHA512:
-  metadata.gz: 3b0f0f8e654453f06fd16d31324b8d3cfa069411e206cbc3b58575987984bda9ece9156411121d5202c701fd4dcece6ed5ab7b40eac5d5116a02f3347f2e0a4c
-  data.tar.gz: 355f0fec168526d3e881efb0b9ef5434089d2bc531adeb6f6dc9af61ea96dbb4a30600d744babd82dd57df2b6157d36a1d4e9ed837af902295d8419b7e5bfe91
+  metadata.gz: b4e5420f0c6aaad0e1e13ed296bc598e88b16974bfbaa7e55cc1680ad4ca499ba0b570de3ee26d72a993cbb9e712370f7e23fcf14e56e46ba40d7c601c5695f1
+  data.tar.gz: 93cf5acde18b71f512f2f68eaec1ba8191a721e1ace7853604d9e6ac4c6c7d03ae88a19c402a4c8b8545e8bfa5546de4ced97dfa032536f18747a5658419b752

data/README.md

@@ -22,16 +22,31 @@ gem 'activerecord_json_validator'
 ## Usage
 
 ### JSON Schema
+Schemas must use be a JSON string or use string keys.
 
 ```json
-{
+'{
   "type": "object",
-  "$schema": "http://json-schema.org/draft-04/schema",
+  "$schema": "http://json-schema.org/draft-04/schema#",
   "properties": {
     "city": { "type": "string" },
     "country": { "type": "string" }
   },
   "required": ["country"]
+}'
+```
+
+or
+
+```ruby
+{
+  "type" => "object",
+  "$schema" => "http://json-schema.org/draft-04/schema#",
+  "properties" => {
+    "city" => { "type" => "string" },
+    "country" => { "type" => "string" }
+  },
+  "required" => ["country"]
 }
 ```
 
@@ -69,13 +84,12 @@ user.profile_invalid_json # => '{invalid JSON":}'
 |------------|-----------------------------------------------------
 | `:schema`  | The JSON schema to validate the data against (see **Schema** section)
 | `:message` | The ActiveRecord message added to the record errors (see **Message** section)
-| `:options` | A `Hash` of [`json-schema`](https://github.com/ruby-json-schema/json-schema)-supported options to pass to the validator
+| `:options` | A `Hash` of [`json_schemer`](https://github.com/davishmcclurg/json_schemer#options)-supported options to pass to the validator
 
 ##### Schema
 
-`ActiveRecord::JSONValidator` uses the `json-schema` gem to validate the JSON
-data against a JSON schema. You can use [any value](https://github.com/ruby-json-schema/json-schema/tree/master#usage) that
-`JSON::Validator.validate` would take as the `schema` argument.
+`ActiveRecord::JSONValidator` uses the [json_schemer](https://github.com/davishmcclurg/json_schemer) gem to validate the JSON
+data against a JSON schema. 
 
 Additionally, you can use a `Symbol` or a `Proc`. Both will be executed in the
 context of the validated record (`Symbol` will be sent as a method and the

data/activerecord_json_validator.gemspec

@@ -27,6 +27,6 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'phare'
   spec.add_development_dependency 'rubocop', '~> 0.28'
 
-  spec.add_dependency 'json-schema', '~> 2.8'
+  spec.add_dependency 'json_schemer', '~> 0.2.18'
   spec.add_dependency 'activerecord', '>= 4.2.0', '< 7'
 end

data/lib/active_record/json_validator/validator.rb

@@ -14,8 +14,8 @@ class JsonValidator < ActiveModel::EachValidator
 
   # Validate the JSON value with a JSON schema path or String
   def validate_each(record, attribute, value)
-    # Validate value with JSON::Validator
-    errors = ::JSON::Validator.fully_validate(schema(record), validatable_value(value), options.fetch(:options))
+    # Validate value with JSON Schemer
+    errors = JSONSchemer.schema(schema(record), options.fetch(:options)).validate(value).to_a
 
     # Everything is good if we don’t have any errors and we got valid JSON value
     return if errors.empty? && record.send(:"#{attribute}_invalid_json").blank?
@@ -49,7 +49,7 @@ protected
     end
   end
 
-  # Return a valid schema for JSON::Validator.fully_validate, recursively calling
+  # Return a valid schema, recursively calling
   # itself until it gets a non-Proc/non-Symbol value.
   def schema(record, schema = nil)
     schema ||= options.fetch(:schema)
@@ -61,12 +61,6 @@ protected
     end
   end
 
-  def validatable_value(value)
-    return value if value.is_a?(String)
-
-    ::ActiveSupport::JSON.encode(value)
-  end
-
   def message(errors)
     message = options.fetch(:message)
 

data/lib/active_record/json_validator/version.rb

@@ -2,6 +2,6 @@
 
 module ActiveRecord
   module JSONValidator
-    VERSION = '1.3.0'
+    VERSION = '2.0.0'
   end
 end

data/lib/activerecord_json_validator.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require 'active_record'
-require 'json-schema'
+require 'json_schemer'
 
 require 'active_record/json_validator/version'
 require 'active_record/json_validator/validator'

data/spec/json_validator_spec.rb

@@ -42,7 +42,7 @@ describe JsonValidator do
 
   describe :validate_each do
     let(:validator) { JsonValidator.new(options) }
-    let(:options) { { attributes: [attribute], options: { strict: true } } }
+    let(:options) { { attributes: [attribute], options: { format: true } } }
     let(:validate_each!) { validator.validate_each(record, attribute, value) }
 
     # Doubles
@@ -51,16 +51,18 @@ describe JsonValidator do
     let(:record_errors) { double(:errors) }
     let(:value) { double(:value) }
     let(:schema) { double(:schema) }
-    let(:validatable_value) { double(:validatable_value) }
+    let(:schema_validator) { double(:schema_validator) }
+    let(:raw_errors) { double(:raw_errors) }
     let(:validator_errors) { double(:validator_errors) }
 
     before do
       expect(validator).to receive(:schema).with(record).and_return(schema)
-      expect(validator).to receive(:validatable_value).with(value).and_return(validatable_value)
-      expect(::JSON::Validator).to receive(:fully_validate).with(schema, validatable_value, options[:options]).and_return(validator_errors)
+      expect(JSONSchemer).to receive(:schema).with(schema, options[:options]).and_return(schema_validator)
+      expect(schema_validator).to receive(:validate).with(value).and_return(raw_errors)
+      expect(raw_errors).to receive(:to_a).and_return(validator_errors)
     end
 
-    context 'with JSON::Validator errors' do
+    context 'with JSON Schemer errors' do
       before do
         expect(validator_errors).to receive(:empty?).and_return(false)
         expect(record).not_to receive(:"#{attribute}_invalid_json")
@@ -70,7 +72,7 @@ describe JsonValidator do
       specify { validate_each! }
     end
 
-    context 'without JSON::Validator errors but with invalid JSON data' do
+    context 'without JSON Schemer errors but with invalid JSON data' do
       before do
         expect(validator_errors).to receive(:empty?).and_return(true)
         expect(record).to receive(:"#{attribute}_invalid_json").and_return('foo"{]')
@@ -80,7 +82,7 @@ describe JsonValidator do
       specify { validate_each! }
     end
 
-    context 'without JSON::Validator errors and valid JSON data' do
+    context 'without JSON Schemer errors and valid JSON data' do
       before do
         expect(validator_errors).to receive(:empty?).and_return(true)
         expect(record).to receive(:"#{attribute}_invalid_json").and_return(nil)
@@ -155,22 +157,6 @@ describe JsonValidator do
     end
   end
 
-  describe :validatable_value do
-    let(:validator) { JsonValidator.new(options) }
-    let(:options) { { attributes: [:foo] } }
-    let(:validatable_value) { validator.send(:validatable_value, value) }
-
-    context 'with non-String value' do
-      let(:value) { { foo: 'bar' } }
-      it { expect(validatable_value).to eql('{"foo":"bar"}') }
-    end
-
-    context 'with String value' do
-      let(:value) { '{\"foo\":\"bar\"}' }
-      it { expect(validatable_value).to eql(value) }
-    end
-  end
-
   describe :message do
     let(:validator) { JsonValidator.new(options) }
     let(:options) { { attributes: [:foo], message: message_option } }

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activerecord_json_validator
 version: !ruby/object:Gem::Version
-  version: 1.3.0
+  version: 2.0.0
 platform: ruby
 authors:
 - Rémi Prévost
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-08-27 00:00:00.000000000 Z
+date: 2021-06-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -129,19 +129,19 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0.28'
 - !ruby/object:Gem::Dependency
-  name: json-schema
+  name: json_schemer
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.8'
+        version: 0.2.18
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.8'
+        version: 0.2.18
 - !ruby/object:Gem::Dependency
   name: activerecord
   requirement: !ruby/object:Gem::Requirement
@@ -211,7 +211,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.1.6
 signing_key: 
 specification_version: 4
 summary: ActiveRecord::JSONValidator makes it easy to validate JSON attributes with