activerecord_json_validator 0.4.2 → 0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a61f1c0fe63a28ef0a8959b9b42b6213f10b2272
-  data.tar.gz: ed3d3daa9ca75775ff430ce38d9571f1c9903679
+  metadata.gz: e916b93c42c1f418b5138f0680f1f3c6da4caca6
+  data.tar.gz: 891634217d8bf1d6430a919500bc05e0559e058a
 SHA512:
-  metadata.gz: b45bd69284796f7eaca82efb36c445184d35dd3c7c04229246ffbf4a6a21d485c075c8260f883b72193eea6472683430daefb9bec2a284e08eda99855913f7eb
-  data.tar.gz: 91237f18346a8b3e7816996d3b9740428cccd9b89a8c5c1f6f9ec5c24faf312249be6f94ab87cee66dc79a114648892826dd4a96b1b61f27addacfa211286409
+  metadata.gz: dcb7b8ae91f3eca385eab1d8480b9ad60072c6f5ec9cf777565e5279db47946a17f8c280deae9972fdeec22e3e81caa7fc221dee89d19cc1a821b27d7729fd74
+  data.tar.gz: 3eeda53bedb220bd51ea5cacf5e476cb6875acb8ef83fc78222f74e436ca4c3d89cd119544c904edae98a53e76cddd643a339b5654a8335acbc4fd20872c9e77

data/activerecord_json_validator.gemspec

@@ -29,5 +29,4 @@ Gem::Specification.new do |spec|
 
   spec.add_dependency 'json-schema', '~> 2.5'
   spec.add_dependency 'activerecord', '>= 4.1.0', '< 5'
-  spec.add_dependency 'multi_json', '~> 1.10'
 end

data/lib/active_record/json_validator/validator.rb

@@ -2,6 +2,7 @@ class JsonValidator < ActiveModel::EachValidator
   def initialize(options)
     options.reverse_merge!(message: :invalid_json)
     options.reverse_merge!(schema: nil)
+    options.reverse_merge!(options: {})
     @attributes = options[:attributes]
 
     super
@@ -22,18 +23,11 @@ class JsonValidator < ActiveModel::EachValidator
 
   # Validate the JSON value with a JSON schema path or String
   def validate_each(record, attribute, value)
-    begin
-      json_value = JSON.dump(value)
-    rescue JSON::GeneratorError
-      json_value = ''
-    end
-
     # Validate value with JSON::Validator
-    schema = fetch_schema_for_record(record)
-    errors = ::JSON::Validator.fully_validate(schema, json_value)
+    errors = ::JSON::Validator.fully_validate(schema(record), validatable_value(value), options.fetch(:options))
 
     # Everything is good if we don’t have any errors and we got valid JSON value
-    return true if errors.empty? && record.send(:"#{attribute}_invalid_json").blank?
+    return if errors.empty? && record.send(:"#{attribute}_invalid_json").blank?
 
     # Add error message to the attribute
     record.errors.add(attribute, options.fetch(:message), value: value)
@@ -42,7 +36,7 @@ class JsonValidator < ActiveModel::EachValidator
 protected
 
   # Redefine the setter method for the attributes, since we want to
-  # catch any MultiJson::LoadError errors.
+  # catch JSON parsing errors.
   def inject_setter_method(klass, attributes)
     attributes.each do |attribute|
       klass.class_eval <<-RUBY, __FILE__, __LINE__ + 1
@@ -53,7 +47,7 @@ protected
             @#{attribute}_invalid_json = nil
             args = ::ActiveSupport::JSON.decode(args) if args.is_a?(::String)
             super(args)
-          rescue MultiJson::LoadError, JSON::ParserError
+          rescue ActiveSupport::JSON.parse_error
             @#{attribute}_invalid_json = args
             super({})
           end
@@ -62,12 +56,15 @@ protected
     end
   end
 
-  def fetch_schema_for_record(record)
+  def schema(record)
     schema = options.fetch(:schema)
     return schema unless schema.is_a?(Proc)
 
     record.instance_exec(&schema)
   end
-end
 
-JSONValidator = JsonValidator
+  def validatable_value(value)
+    return value if value.is_a?(String)
+    ::ActiveSupport::JSON.encode(value)
+  end
+end

data/lib/active_record/json_validator/version.rb

@@ -1,5 +1,5 @@
 module ActiveRecord
   module JSONValidator
-    VERSION = '0.4.2'
+    VERSION = '0.5'
   end
 end

data/lib/activerecord_json_validator.rb

@@ -1,6 +1,9 @@
 require 'active_record'
 require 'json-schema'
-require 'multi_json'
 
 require 'active_record/json_validator/version'
 require 'active_record/json_validator/validator'
+
+# NOTE: In case `"JSON"` is treated as an acronym by `ActiveSupport::Inflector`,
+# make `JSONValidator` available too.
+JSONValidator = JsonValidator

data/spec/json_validator_spec.rb

@@ -1,100 +1,133 @@
 require 'spec_helper'
 
 describe JsonValidator do
-  before do
-    run_migration do
-      create_table(:users, force: true) do |t|
-        t.string :name
-        t.text :profile
+  describe :initialize do
+    # NOTE: We do not explicitely call `JsonValidator.new` in the tests,
+    # because we let Rails (ActiveModel::Validations) do that when we call
+    # `validates … json: true` on the model.
+    #
+    # This allows us to test the constructor behavior when executed in
+    # different Rails versions that do not pass the same arguments to it.
+    before do
+      run_migration do
+        create_table(:users, force: true) do |t|
+          t.string :name
+          t.text :data
+        end
       end
-    end
 
-    json_schema = schema
-    spawn_model :User do
-      serialize :profile, JSON
-      validates :name, presence: true
-      validates :profile, presence: true, json: { schema: json_schema }
-
-      def dynamic_json_schema
-        {
-          type: 'object',
-          :'$schema' => 'http://json-schema.org/draft-03/schema',
-          properties: {
-            foo: { type: 'string', required: false },
-            bar: { type: 'string', required: true }
-          }
-        }
+      spawn_model 'User' do
+        serialize :data, JSON
+        validates :data, json: true
       end
-    end
-  end
 
-  let(:user) { User.create(attributes) }
-  let(:schema) do
-    {
-      type: 'object',
-      :'$schema' => 'http://json-schema.org/draft-03/schema',
-      properties: {
-        city: { type: 'string', required: false },
-        country: { type: 'string', required: true }
-      }
-    }
-  end
+      record.data = data
+    end
 
-  context 'with blank JSON value' do
-    let(:attributes) { { name: 'Samuel Garneau', profile: {} } }
-    it { expect(user).to_not be_valid }
-  end
+    let(:record) { User.new }
 
-  context 'with invalid JSON value' do
-    context 'as Ruby Hash' do
-      let(:attributes) { { name: 'Samuel Garneau', profile: { city: 'Quebec City' } } }
-      it { expect(user).to_not be_valid }
+    context 'with valid JSON data' do
+      let(:data) { 'What? This is not JSON at all.' }
+      it { expect(record.data_invalid_json).to eql(data) }
     end
 
-    context 'as JSON string' do
-      let(:attributes) { { name: 'Samuel Garneau', profile: '{ "city": "Quebec City" }' } }
-      it { expect(user).to_not be_valid }
+    context 'with invalid JSON data' do
+      let(:data) { { foo: 'bar' } }
+      it { expect(record.data_invalid_json).to be_nil }
     end
   end
 
-  context 'with valid JSON value' do
-    context 'as Ruby Hash' do
-      let(:attributes) { { name: 'Samuel Garneau', profile: { country: 'CA' } } }
-      it { expect(user).to be_valid }
+  describe :validate_each do
+    let(:validator) { JsonValidator.new(options) }
+    let(:options) { { attributes: [attribute], options: { strict: true } } }
+    let(:validate_each!) { validator.validate_each(record, attribute, value) }
+
+    # Doubles
+    let(:attribute) { double(:attribute, to_s: 'attribute_name') }
+    let(:record) { double(:record, errors: record_errors) }
+    let(:record_errors) { double(:errors) }
+    let(:value) { double(:value) }
+    let(:schema) { double(:schema) }
+    let(:validatable_value) { double(:validatable_value) }
+    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)
     end
 
-    context 'as JSON string' do
-      let(:attributes) { { name: 'Samuel Garneau', profile: '{ "country": "CA" }' } }
-      it { expect(user).to be_valid }
+    context 'with JSON::Validator errors' do
+      before do
+        expect(validator_errors).to receive(:empty?).and_return(false)
+        expect(record).not_to receive(:"#{attribute}_invalid_json")
+        expect(record_errors).to receive(:add).with(attribute, options[:message], value: value)
+      end
+
+      specify { validate_each! }
     end
-  end
 
-  context 'with malformed JSON string' do
-    let(:attributes) { { name: 'Samuel Garneau', profile: 'foo:}bar' } }
+    context 'without JSON::Validator 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"{]')
+        expect(record_errors).to receive(:add).with(attribute, options[:message], value: value)
+      end
 
-    specify do
-      expect(user).to_not be_valid
-      expect(user.profile).to eql({})
-      expect(user.profile_invalid_json).to eql('foo:}bar')
+      specify { validate_each! }
+    end
+
+    context 'without JSON::Validator 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)
+        expect(record_errors).not_to receive(:add)
+      end
+
+      specify { validate_each! }
     end
   end
 
-  context 'with lambda schema option' do
-    # The dynamic schema makes `country` and `city` keys mandatory
-    let(:schema) { -> { dynamic_json_schema } }
+  describe :schema do
+    let(:validator) { JsonValidator.new(options) }
+    let(:options) { { attributes: [:foo], schema: schema_option } }
+    let(:schema) { validator.send(:schema, record) }
+
+    context 'with non-Proc schema' do
+      let(:schema_option) { double(:schema) }
+      let(:record) { double(:record) }
 
-    context 'with valid JSON value' do
-      let(:attributes) { { name: 'Samuel Garneau', profile: { foo: 'bar', bar: 'foo' } } }
-      it { expect(user).to be_valid }
+      it { expect(schema).to eql(schema_option) }
     end
 
-    context 'with invalid JSON value' do
-      let(:attributes) { { name: 'Samuel Garneau', profile: {} } }
-      it { expect(user).not_to be_valid }
+    context 'with Proc schema' do
+      let(:schema_option) { -> { dynamic_schema } }
+      let(:record) { record_class.new }
+      let(:record_class) do
+        Class.new do
+          def dynamic_schema
+            :yay
+          end
+        end
+      end
+
+      it { expect(schema).to eql(:yay) }
     end
   end
 
-  context 'with JSON inflection' do
-    it { expect(JSONValidator).to equal(JsonValidator) }
+  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
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activerecord_json_validator
 version: !ruby/object:Gem::Version
-  version: 0.4.2
+  version: '0.5'
 platform: ruby
 authors:
 - Rémi Prévost
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-01-29 00:00:00.000000000 Z
+date: 2015-02-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -162,20 +162,6 @@ dependencies:
     - - "<"
       - !ruby/object:Gem::Version
         version: '5'
-- !ruby/object:Gem::Dependency
-  name: multi_json
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.10'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.10'
 description: ActiveRecord::JSONValidator makes it easy to validate JSON attributes
   with a JSON schema.
 email: