activerecord_json_validator 1.3.0 → 3.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d9dce365377ebd51d3f5b8156e3cf928507014ed1278c0ca794675b4fecd3d2c
-  data.tar.gz: b1f58a7b215df70ff616dd80ee31dd24dd8fa0b0020189ee99318fb577a38621
+  metadata.gz: 90252b743670b3c94e3ac700b868c698cf9b94124f115fa7b39b27b63f66445a
+  data.tar.gz: 8de9a2eeb74864be691a63ecb9a27f286d669949221b78f70db62ecbb3f9b62c
 SHA512:
-  metadata.gz: 3b0f0f8e654453f06fd16d31324b8d3cfa069411e206cbc3b58575987984bda9ece9156411121d5202c701fd4dcece6ed5ab7b40eac5d5116a02f3347f2e0a4c
-  data.tar.gz: 355f0fec168526d3e881efb0b9ef5434089d2bc531adeb6f6dc9af61ea96dbb4a30600d744babd82dd57df2b6157d36a1d4e9ed837af902295d8419b7e5bfe91
+  metadata.gz: abdacc70526c1c9be8b5d3585283eaa594fe0c48116aab7eac9ca19a5553fcae69a409986e3793eb96c9ab80624d74f8556c69c0f3994a88987a5d83f9a84266
+  data.tar.gz: a170d66db92dcc1bc0e3eb9ebe75fb939ccecb85d952cc18b590aa8404562ddf0093edbe4993d1a16b11ba1efa5135e78e2b957f5ef114a41e8e0399cfcc08c5

data/.github/workflows/ci.yaml

@@ -0,0 +1,37 @@
+name: CI
+
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+    branches:
+      - '**'
+
+jobs:
+  ci:
+    runs-on: ubuntu-latest
+
+    services:
+      db:
+        image: postgres:10.19
+        env:
+          POSTGRES_DB: activerecord_json_validator_test
+          POSTGRES_USER: postgres
+          POSTGRES_PASSWORD: postgres
+        ports: ['5432:5432']
+        options: --health-cmd pg_isready --health-interval 10s --health-timeout 5s --health-retries 5
+
+    env:
+      CANONICAL_HOST: localhost
+      DATABASE_URL: postgres://postgres:postgres@localhost/activerecord_json_validator_test
+      DB_ADAPTER: postgresql
+
+    steps:
+      - uses: actions/checkout@v2
+      - uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: '2.7.5'
+          bundler-cache: true
+      - run: bundle exec rubocop
+      - run: bundle exec rake spec

data/.rubocop.yml

@@ -1,6 +1,11 @@
 AllCops:
+  Include:
+    - Rakefile
+    - Gemfile
+    - '**/*.rb'
   Exclude:
     - activerecord_json_validator.gemspec
+    - vendor/**/*
 
 Documentation:
   Enabled: false

data/LICENSE.md

@@ -1,4 +1,4 @@
-Copyright (c) 2013-2016, Mirego
+Copyright (c) 2013-2024, Mirego
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without

data/README.md

@@ -1,12 +1,12 @@
 <p align="center">
   <a href="https://github.com/mirego/activerecord_json_validator">
-    <img src="https://cloud.githubusercontent.com/assets/11348/6099354/cffcf35e-afc3-11e4-9a4d-d872941bbcf6.png" alt="" />
+    <img src="https://user-images.githubusercontent.com/11348/126779905-3468eb15-d554-46d5-925b-235f68169d86.png" alt="" />
   </a>
   <br />
-  <code>ActiveRecord::JSONValidator</code> makes it easy to validate<br /> JSON attributes against a <a href="http://json-schema.org/">JSON schema</a>.
+  <code>ActiveRecord::JSONValidator</code> makes it easy to validate<br /> JSON attributes against a <a href="https://json-schema.org/">JSON schema</a>.
   <br /><br />
-  <a href="https://rubygems.org/gems/activerecord_json_validator"><img src="http://img.shields.io/gem/v/activerecord_json_validator.svg" /></a>
-  <a href="https://travis-ci.org/mirego/activerecord_json_validator"><img src="http://img.shields.io/travis/mirego/activerecord_json_validator.svg" /></a>
+  <a href="https://rubygems.org/gems/activerecord_json_validator"><img src="https://img.shields.io/gem/v/activerecord_json_validator.svg" /></a>
+  <a href="https://github.com/mirego/activerecord_json_validator/actions/workflows/ci.yaml"><img src="https://github.com/mirego/activerecord_json_validator/actions/workflows/ci.yaml/badge.svg" /></a>
 </p>
 
 ---
@@ -16,17 +16,19 @@
 Add this line to your application's Gemfile:
 
 ```ruby
-gem 'activerecord_json_validator'
+gem 'activerecord_json_validator', '~> 3.0.0'
 ```
 
 ## Usage
 
 ### JSON Schema
 
+Schemas should be a JSON file
+
 ```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" }
@@ -45,7 +47,7 @@ end
 
 class User < ActiveRecord::Base
   # Constants
-  PROFILE_JSON_SCHEMA = Rails.root.join('config', 'schemas', 'profile.json_schema').to_s
+  PROFILE_JSON_SCHEMA = Rails.root.join('config', 'schemas', 'profile.json')
 
   # Validations
   validates :name, presence: true
@@ -65,17 +67,17 @@ user.profile_invalid_json # => '{invalid JSON":}'
 
 #### Options
 
-| Option     | Description
-|------------|-----------------------------------------------------
-| `: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
+| Option     | Description                                                                                                                    |
+| ---------- | ------------------------------------------------------------------------------------------------------------------------------ |
+| `:schema`  | The JSON schema to validate the data against (see **Schema** section)                                                          |
+| `:value`   | The actual value to use when validating (see **Value** section)                                                                |
+| `:message` | The ActiveRecord message added to the record errors (see **Message** section)                                                  |
+| `: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
@@ -84,8 +86,8 @@ context of the validated record (`Symbol` will be sent as a method and the
 ```ruby
 class User < ActiveRecord::Base
   # Constants
-  PROFILE_REGULAR_JSON_SCHEMA = Rails.root.join('config', 'schemas', 'profile.json_schema').to_s
-  PROFILE_ADMIN_JSON_SCHEMA = Rails.root.join('config', 'schemas', 'profile_admin.json_schema').to_s
+  PROFILE_REGULAR_JSON_SCHEMA = Rails.root.join('config', 'schemas', 'profile.json_schema')
+  PROFILE_ADMIN_JSON_SCHEMA = Rails.root.join('config', 'schemas', 'profile_admin.json_schema')
 
   # Validations
   validates :profile, presence: true, json: { schema: lambda { dynamic_profile_schema } } # `schema: :dynamic_profile_schema` would also work
@@ -96,6 +98,48 @@ class User < ActiveRecord::Base
 end
 ```
 
+The schema is passed to the `JSONSchemer.schema` function, so it can be anything supported by it:
+
+```ruby
+class User < ActiveRecord::Base
+  # Constants
+  JSON_SCHEMA = Rails.root.join('config', 'schemas', 'profile.json_schema')
+  # JSON_SCHEMA = { 'type' => 'object', 'properties' => { 'foo' => { 'type' => 'integer', 'minimum' => 3 } } }
+  # JSON_SCHEMA = '{"type":"object","properties":{"foo":{"type":"integer","minimum":3}}}'
+
+  # Validations
+  validates :profile, presence: true, json: { schema: JSON_SCHEMA }
+end
+```
+
+##### Value
+
+By default, the validator will use the “getter” method to the fetch attribute
+value and validate the schema against it.
+
+```ruby
+# Will validate `self.foo`
+validates :foo, json: { schema: SCHEMA }
+```
+
+But you can change this behavior if the getter method doesn’t return raw JSON data (a `Hash`):
+
+```ruby
+# Will validate `self[:foo]`
+validates :foo, json: { schema: SCHEMA, value: ->(record, _, _) { record[:foo] } }
+```
+
+You could also implement a “raw getter” if you want to avoid the `value` option:
+
+```ruby
+# Will validate `self[:foo]`
+validates :raw_foo, json: { schema: SCHEMA }
+
+def raw_foo
+  self[:foo]
+end
+```
+
 ##### Message
 
 Like any other ActiveModel validation, you can specify either a `Symbol` or
@@ -120,14 +164,23 @@ user.errors.full_messages
 #    ]
 ```
 
+## Development
+
+The tests require a database. We've provided a simple `docker-compose.yml` that will make
+it trivial to run the tests against PostgreSQL. Simply run `docker compose up -d`
+followed by `rake spec`. When you're done, run `docker compose down` to stop the database.
+
+In order to use another database, simply define the `DATABASE_URL` environment variable
+appropriately.
+
 ## License
 
-`ActiveRecord::JSONValidator` is © 2013-2016 [Mirego](http://www.mirego.com) and may be freely distributed under the [New BSD license](http://opensource.org/licenses/BSD-3-Clause).  See the [`LICENSE.md`](https://github.com/mirego/activerecord_json_validator/blob/master/LICENSE.md) file.
+`ActiveRecord::JSONValidator` is © 2013-2024 [Mirego](https://www.mirego.com) and may be freely distributed under the [New BSD license](https://opensource.org/licenses/BSD-3-Clause). See the [`LICENSE.md`](https://github.com/mirego/activerecord_json_validator/blob/master/LICENSE.md) file.
 
-The tree logo is based on [this lovely icon](http://thenounproject.com/term/tree/51004/) by [Sara Quintana](http://thenounproject.com/sara.quintana.75), from The Noun Project. Used under a [Creative Commons BY 3.0](http://creativecommons.org/licenses/by/3.0/) license.
+The tree logo is based on [this lovely icon](https://thenounproject.com/term/tree/51004/) by [Sara Quintana](https://thenounproject.com/sara.quintana.75), from The Noun Project. Used under a [Creative Commons BY 3.0](https://creativecommons.org/licenses/by/3.0/) license.
 
 ## About Mirego
 
-[Mirego](http://mirego.com) is a team of passionate people who believe that work is a place where you can innovate and have fun. We're a team of [talented people](http://life.mirego.com) who imagine and build beautiful Web and mobile applications. We come together to share ideas and [change the world](http://mirego.org).
+[Mirego](https://www.mirego.com) is a team of passionate people who believe that work is a place where you can innovate and have fun. We're a team of [talented people](https://life.mirego.com) who imagine and build beautiful Web and mobile applications. We come together to share ideas and [change the world](https://www.mirego.org).
 
-We also [love open-source software](http://open.mirego.com) and we try to give back to the community as much as we can.
+We also [love open-source software](https://open.mirego.com) and we try to give back to the community as much as we can.

data/activerecord_json_validator.gemspec

@@ -18,15 +18,15 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ['lib']
 
-  spec.add_development_dependency 'bundler', '~> 1.12'
+  spec.add_development_dependency 'bundler', '>= 1.12'
   spec.add_development_dependency 'rake'
   spec.add_development_dependency 'rspec', '~> 3.5'
   spec.add_development_dependency 'pg'
-  spec.add_development_dependency 'mysql2'
-  spec.add_development_dependency 'activesupport', '>= 4.2.0', '< 7'
-  spec.add_development_dependency 'phare'
+  spec.add_development_dependency 'activesupport', '>= 4.2.0', '< 9'
   spec.add_development_dependency 'rubocop', '~> 0.28'
+  spec.add_development_dependency 'rubocop-rspec', '~> 1.44'
+  spec.add_development_dependency 'rubocop-standard', '~> 6.0'
 
-  spec.add_dependency 'json-schema', '~> 2.8'
-  spec.add_dependency 'activerecord', '>= 4.2.0', '< 7'
+  spec.add_dependency 'json_schemer', '~> 2.2'
+  spec.add_dependency 'activerecord', '>= 4.2.0', '< 9'
 end

data/docker-compose.yml

@@ -0,0 +1,11 @@
+version: '3.2'
+
+services:
+  postgres:
+    image: postgres:10
+    ports:
+      - 5432:5432
+    restart: on-failure
+    environment:
+      POSTGRES_DB: activerecord_json_validator_test
+      POSTGRES_HOST_AUTH_METHOD: trust # don't require password

data/lib/active_record/json_validator/validator.rb

@@ -5,6 +5,7 @@ class JsonValidator < ActiveModel::EachValidator
     options.reverse_merge!(message: :invalid_json)
     options.reverse_merge!(schema: nil)
     options.reverse_merge!(options: {})
+    options.reverse_merge!(value: ->(_record, _attribute, value) { value })
     @attributes = options[:attributes]
 
     super
@@ -14,15 +15,20 @@ 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))
+    # Get the _actual_ attribute value, not the getter method value
+    value = options.fetch(:value).call(record, attribute, value)
+
+    # 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?
 
     # Add error message to the attribute
+    details = errors.map { |e| e.fetch('error') }
     message(errors).each do |error|
-      record.errors.add(attribute, error, value: value)
+      error = error.fetch('error') if error.is_a?(Hash)
+      record.errors.add(attribute, error, errors: details, value: value)
     end
   end
 
@@ -31,25 +37,27 @@ protected
   # Redefine the setter method for the attributes, since we want to
   # catch JSON parsing errors.
   def inject_setter_method(klass, attributes)
+    return if klass.nil?
+
     attributes.each do |attribute|
-      klass.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+      klass.prepend(Module.new do
         attr_reader :"#{attribute}_invalid_json"
 
         define_method "#{attribute}=" do |args|
           begin
-            @#{attribute}_invalid_json = nil
+            instance_variable_set("@#{attribute}_invalid_json", nil)
             args = ::ActiveSupport::JSON.decode(args) if args.is_a?(::String)
             super(args)
           rescue ActiveSupport::JSON.parse_error
-            @#{attribute}_invalid_json = args
+            instance_variable_set("@#{attribute}_invalid_json", args)
             super({})
           end
         end
-      RUBY
+      end)
     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,18 +69,9 @@ 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)
-
-    case message
-      when Proc then [message.call(errors)].flatten if message.is_a?(Proc)
-      else [message]
-    end
+    message = message.call(errors) if message.is_a?(Proc)
+    [message].flatten
   end
 end

data/lib/active_record/json_validator/version.rb

@@ -2,6 +2,6 @@
 
 module ActiveRecord
   module JSONValidator
-    VERSION = '1.3.0'
+    VERSION = '3.1.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

@@ -3,106 +3,109 @@
 # rubocop:disable Metrics/BlockLength
 require 'spec_helper'
 
+module CountryDefaulter
+  extend ActiveSupport::Concern
+
+  class_methods do
+    def default_country_attribute(name, country:)
+      define_method("#{name}=") do |value|
+        self[name] = { country: country }.merge(value)
+      end
+    end
+  end
+end
+
 describe JsonValidator do
-  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.
+  describe :validate_each do
     before do
       run_migration do
         create_table(:users, force: true) do |t|
-          t.string :name
           t.text :data
+          t.json :smart_data
         end
       end
 
       spawn_model 'User' do
-        serialize :data, JSON
-        validates :data, json: true
+        include CountryDefaulter
+
+        schema = '
+        {
+          "type": "object",
+          "properties": {
+            "city": { "type": "string" },
+            "country": { "type": "string" }
+          },
+          "required": ["country"]
+        }
+        '
+
+        default_country_attribute :smart_data, country: 'Canada'
+
+        serialize :data, coder: JSON
+        serialize :other_data, coder: JSON
+        validates :data, json: { schema: schema, message: ->(errors) { errors } }
+        validates :other_data, json: { schema: schema, message: ->(errors) { errors.map { |error| error['details'].to_a.flatten.join(' ') } } }
+        validates :smart_data, json: { value: ->(record, _, _) { record[:smart_data] }, schema: schema, message: ->(errors) { errors } }
+
+        def smart_data
+          OpenStruct.new(self[:smart_data])
+        end
       end
-
-      record.data = data
     end
 
-    let(:record) { User.new }
+    context 'with valid JSON data but schema errors' do
+      let(:user) do
+        User.new(
+          data: '{"city":"Quebec City"}',
+          other_data: '{"city":"Quebec City"}',
+          smart_data: { country: 'Ireland', city: 'Dublin' }
+        )
+      end
 
-    context 'with valid JSON data' do
-      let(:data) { 'What? This is not JSON at all.' }
-      it { expect(record.data_invalid_json).to eql(data) }
+      specify do
+        expect(user).not_to be_valid
+        expect(user.errors.full_messages).to eql(['Data object at root is missing required properties: country', 'Other data missing_keys country'])
+        expect(user.errors.group_by_attribute[:data].first).to have_attributes(
+          options: include(errors: ['object at root is missing required properties: country'])
+        )
+        expect(user.errors.group_by_attribute[:other_data].first).to have_attributes(
+          options: include(errors: ['object at root is missing required properties: country'])
+        )
+        expect(user.data).to eql({ 'city' => 'Quebec City' })
+        expect(user.data_invalid_json).to be_nil
+        expect(user.smart_data.city).to eql('Dublin')
+        expect(user.smart_data.country).to eql('Ireland')
+      end
     end
 
     context 'with invalid JSON data' do
-      let(:data) { { foo: 'bar' } }
-      it { expect(record.data_invalid_json).to be_nil }
-    end
-  end
-
-  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 '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
+      let(:data) { 'What? This is not JSON at all.' }
+      let(:user) { User.new(data: data, smart_data: data) }
 
-      specify { validate_each! }
-    end
+      specify do
+        expect(user.data_invalid_json).to eql(data)
+        expect(user.data).to eql({})
 
-    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)
+        # Ensure that both setters ran
+        expect(user.smart_data_invalid_json).to eql(data)
+        expect(user.smart_data).to eql(OpenStruct.new({ country: 'Canada' }))
       end
-
-      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)
+    context 'with missing country in smart data' do
+      let(:user) do
+        User.new(
+          data: '{"city":"Quebec City","country":"Canada"}',
+          other_data: '{"city":"Quebec City","country":"Canada"}',
+          smart_data: { city: 'Quebec City' }
+        )
       end
 
-      specify { validate_each! }
-    end
-
-    context 'with multiple error messages' do
-      let(:options) { { attributes: [attribute], message: message, options: { strict: true } } }
-      let(:message) { ->(errors) { errors.to_a } }
-
-      before do
-        expect(validator_errors).to receive(:empty?).and_return(false)
-        expect(validator_errors).to receive(:to_a).and_return(%i[first_error second_error])
-        expect(record).not_to receive(:"#{attribute}_invalid_json")
-        expect(record_errors).to receive(:add).with(attribute, :first_error, value: value)
-        expect(record_errors).to receive(:add).with(attribute, :second_error, value: value)
+      specify do
+        expect(user).to be_valid
+        expect(user.smart_data.city).to eql('Quebec City')
+        expect(user.smart_data.country).to eql('Canada') # Due to CountryDefaulter
       end
-
-      specify { validate_each! }
     end
   end
 
@@ -155,22 +158,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 } }

data/spec/spec_helper.rb

@@ -4,7 +4,6 @@ $LOAD_PATH.unshift File.expand_path('lib', __dir__)
 
 require 'active_support/all'
 require 'rspec'
-require 'mysql2'
 require 'pg'
 
 require 'activerecord_json_validator'

data/spec/support/macros/database/database_adapter.rb

@@ -6,6 +6,6 @@ class DatabaseAdapter
   end
 
   def establish_connection!
-    ActiveRecord::Base.establish_connection(database_configuration)
+    ActiveRecord::Base.establish_connection(ENV.fetch('DATABASE_URL', 'postgres://postgres@localhost/activerecord_json_validator_test'))
   end
 end

data/spec/support/macros/database/mysql_adapter.rb

@@ -3,15 +3,6 @@
 require_relative 'database_adapter'
 
 class Mysql2Adapter < DatabaseAdapter
-  def database_configuration
-    {
-      adapter: 'mysql2',
-      database: @database,
-      username: 'travis',
-      encoding: 'utf8'
-    }
-  end
-
   def reset_database!
     ActiveRecord::Base.connection.execute("SELECT concat('DROP TABLE IF EXISTS ', table_name, ';') FROM information_schema.tables WHERE table_schema = '#{@database}';")
   end

data/spec/support/macros/database/postgresql_adapter.rb

@@ -3,15 +3,6 @@
 require_relative 'database_adapter'
 
 class PostgresqlAdapter < DatabaseAdapter
-  def database_configuration
-    {
-      adapter: 'postgresql',
-      database: @database,
-      user: 'postgres',
-      schema_search_path: 'public'
-    }
-  end
-
   def reset_database!
     ActiveRecord::Base.connection.execute('drop schema public cascade;')
     ActiveRecord::Base.connection.execute('create schema public;')

data/spec/support/macros/database_macros.rb

@@ -25,6 +25,6 @@ module DatabaseMacros
     adapter.reset_database!
 
     # Silence everything
-    ActiveRecord::Base.logger = ActiveRecord::Migration.verbose = false
+    ActiveRecord::Base.logger = ActiveRecord::Migration.verbose = nil
   end
 end

metadata

@@ -1,27 +1,27 @@
 --- !ruby/object:Gem::Specification
 name: activerecord_json_validator
 version: !ruby/object:Gem::Version
-  version: 1.3.0
+  version: 3.1.0
 platform: ruby
 authors:
 - Rémi Prévost
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2019-08-27 00:00:00.000000000 Z
+date: 2025-01-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '1.12'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '1.12'
 - !ruby/object:Gem::Dependency
@@ -67,81 +67,81 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: mysql2
+  name: activesupport
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 4.2.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '9'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 4.2.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '9'
 - !ruby/object:Gem::Dependency
-  name: activesupport
+  name: rubocop
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 4.2.0
-    - - "<"
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '7'
+        version: '0.28'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 4.2.0
-    - - "<"
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '7'
+        version: '0.28'
 - !ruby/object:Gem::Dependency
-  name: phare
+  name: rubocop-rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.44'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.44'
 - !ruby/object:Gem::Dependency
-  name: rubocop
+  name: rubocop-standard
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.28'
+        version: '6.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.28'
+        version: '6.0'
 - !ruby/object:Gem::Dependency
-  name: json-schema
+  name: json_schemer
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.8'
+        version: '2.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.8'
+        version: '2.2'
 - !ruby/object:Gem::Dependency
   name: activerecord
   requirement: !ruby/object:Gem::Requirement
@@ -151,7 +151,7 @@ dependencies:
         version: 4.2.0
     - - "<"
       - !ruby/object:Gem::Version
-        version: '7'
+        version: '9'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -161,7 +161,7 @@ dependencies:
         version: 4.2.0
     - - "<"
       - !ruby/object:Gem::Version
-        version: '7'
+        version: '9'
 description: ActiveRecord::JSONValidator makes it easy to validate JSON attributes
   with a JSON schema.
 email:
@@ -170,18 +170,16 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/workflows/ci.yaml"
 - ".gitignore"
 - ".rspec"
 - ".rubocop.yml"
-- ".travis.yml"
 - Gemfile
 - LICENSE.md
 - README.md
 - Rakefile
 - activerecord_json_validator.gemspec
-- gemfiles/Gemfile.activerecord-4.2.x
-- gemfiles/Gemfile.activerecord-5.0.x
-- gemfiles/Gemfile.activerecord-6.0.x
+- docker-compose.yml
 - lib/active_record/json_validator/validator.rb
 - lib/active_record/json_validator/version.rb
 - lib/activerecord_json_validator.rb
@@ -196,7 +194,7 @@ homepage: https://github.com/mirego/activerecord_json_validator
 licenses:
 - BSD 3-Clause
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -211,8 +209,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
-signing_key: 
+rubygems_version: 3.5.11
+signing_key:
 specification_version: 4
 summary: ActiveRecord::JSONValidator makes it easy to validate JSON attributes with
   a JSON schema.

data/.travis.yml

@@ -1,33 +0,0 @@
-language: ruby
-
-rvm:
-  - 2.4.6
-  - 2.6.3
-
-gemfile:
-  - gemfiles/Gemfile.activerecord-4.2.x
-  - gemfiles/Gemfile.activerecord-5.0.x
-  - gemfiles/Gemfile.activerecord-6.0.x
-
-matrix:
-  exclude:
-  - gemfile: gemfiles/Gemfile.activerecord-6.0.x
-    rvm: 2.4.6
-
-sudo: false
-
-services:
-  - mysql
-  - postgresql
-
-env:
-  - DB_ADAPTER=mysql2
-  - DB_ADAPTER=postgresql
-
-before_script:
-  - mysql -e 'create database activerecord_json_validator_test;'
-  - psql -c 'create database activerecord_json_validator_test;' -U postgres
-
-script:
-  - 'echo "Checking code style" && bundle exec phare'
-  - 'echo "Running tests" && bundle exec rake spec'

data/gemfiles/Gemfile.activerecord-4.2.x

@@ -1,6 +0,0 @@
-source 'https://rubygems.org'
-
-gemspec path: '../'
-
-gem 'activerecord', '~> 4.2'
-gem 'pg', '~> 0.15'

data/gemfiles/Gemfile.activerecord-5.0.x

@@ -1,5 +0,0 @@
-source 'https://rubygems.org'
-
-gemspec path: '../'
-
-gem 'activerecord', '~> 5.0'

data/gemfiles/Gemfile.activerecord-6.0.x

@@ -1,5 +0,0 @@
-source 'https://rubygems.org'
-
-gemspec path: '../'
-
-gem 'activerecord', '~> 6.0'