db_validator 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 60cba1d36771e30b0bafb5ac354f3d741b3bde0e5f37b267bcff4ebb9dd11bad
-  data.tar.gz: 1baa177ce745a107d5c064844b74cd8731b5cddd8624f2944c464812c9e136b0
+  metadata.gz: 527983d42b2851e593a40202407ff01d8b82cb13c97741239307d21a12416567
+  data.tar.gz: 389a234732560ec7f0fcf1ba9c0bb995d9552a842719d75f20569b9d7f86818e
 SHA512:
-  metadata.gz: d3e414c08cf3496438f5a61941c579b072dd9a41330133df64bfe48c3e8d205cf3de933f52368622d3cd7cbcea8cea5844982f7fb95bf1eafca59bcb1b6f781a
-  data.tar.gz: 9a2d9de68775b836aec350ded2b88184c534e3dac4649d6b531e5f5575363f30ee60b1a10a9439cfbd2beb083ea2036a095a17d37c5593d9fe4e730bdb7349fe
+  metadata.gz: e4cec830738a0de711477620603757c2fade101075d64a9cbf824ecef806a994c7e0da655add3f495e2ac828a15a3e2b7db0143e32718a6aebbfa3fa3911fc70
+  data.tar.gz: e3a6d02dd6ce60e17e0ecdf5a255d0fe9886fc7533e0ad8c7334c0f3d0c03970c0aa4b01bdd90fa8342c3cb4225816b3a3658908e2e23e2ccfae2aa8fd1fc286

data/lib/db_validator/cli.rb

@@ -3,11 +3,30 @@
 require "tty-prompt"
 require "tty-box"
 require "tty-spinner"
+require "optparse"
+require "logger"
 
 module DbValidator
   class CLI
     def initialize
       @prompt = TTY::Prompt.new
+      @options = {}
+    end
+
+    def start
+      if ARGV.empty?
+        interactive_mode
+      else
+        parse_command_line_args
+        validate_with_options
+      end
+    end
+
+    def display_progress(message)
+      spinner = TTY::Spinner.new("[:spinner] #{message}", format: :dots)
+      spinner.auto_spin
+      yield if block_given?
+      spinner.success
     end
 
     def select_models(available_models)
@@ -40,37 +59,89 @@ module DbValidator
       end
     end
 
-    def configure_options
-      options = {}
-
-      @prompt.say("\n")
-      if @prompt.yes?("Would you like to configure additional options?", default: false)
-        limit_input = @prompt.ask("Enter record limit (leave blank for no limit):") do |q|
-          q.validate(/^\d*$/, "Please enter a valid number")
-          q.convert(:int, nil)
+    def parse_command_line_args # rubocop:disable Metrics/AbcSize
+      args = ARGV.join(" ").split(/\s+/)
+      args.each do |arg|
+        key, value = arg.split("=")
+        case key
+        when "models"
+          @options[:only_models] = value.split(",").map(&:strip).map(&:classify)
+        when "limit"
+          @options[:limit] = value.to_i
+        when "format"
+          @options[:report_format] = value.to_sym
+        when "show_records"
+          @options[:show_records] = value.to_sym
         end
-        options[:limit] = limit_input if limit_input.present?
+      end
+    end
 
-        batch_size = @prompt.ask("Enter batch size:", default: 1000, convert: :int) do |q|
-          q.validate(/^\d+$/, "Please enter a positive number")
-          q.messages[:valid?] = "Please enter a positive number"
-        end
-        options[:batch_size] = batch_size if batch_size.present?
+    def validate_with_options
+      load_rails
+      configure_validator(@options[:only_models], @options)
+      validator = DbValidator::Validator.new
+      report = validator.validate_all
+      Rails.logger.debug { "\n#{report}" }
+    end
 
-        options[:format] = @prompt.select("Select report format:", %w[text json], default: "text")
+    def interactive_mode
+      load_rails
+      display_header
+
+      display_progress("Loading models") do
+        Rails.application.eager_load!
       end
 
-      options
+      available_models = ActiveRecord::Base.descendants
+                                           .reject(&:abstract_class?)
+                                           .select(&:table_exists?)
+                                           .map(&:name)
+                                           .sort
+
+      if available_models.empty?
+        Rails.logger.debug "No models found in the application."
+        exit 1
+      end
+
+      selected_models = select_models(available_models)
+      options = configure_options
+
+      configure_validator(selected_models, options)
+      validator = DbValidator::Validator.new
+      report = validator.validate_all
+      Rails.logger.debug { "\n#{report}" }
     end
 
-    def display_progress(message)
-      spinner = TTY::Spinner.new("[:spinner] #{message}", format: :dots)
-      spinner.auto_spin
-      yield if block_given?
-      spinner.success
+    def load_rails
+      require File.expand_path("config/environment", Dir.pwd)
+    rescue LoadError
+      Rails.logger.debug "Error: Rails application not found. Please run this command from your Rails application root."
+      exit 1
     end
 
-    private
+    def configure_validator(models = nil, options = {})
+      config = DbValidator.configuration
+      config.only_models = models if models
+      config.limit = options[:limit] if options[:limit]
+      config.batch_size = options[:batch_size] if options[:batch_size]
+      config.report_format = options[:format] if options[:format]
+      config.show_records = options[:show_records] if options[:show_records]
+    end
+
+    def configure_options
+      options = {}
+
+      @prompt.say("\n")
+      limit_input = @prompt.ask("Enter record limit (leave blank for no limit):") do |q|
+        q.validate(/^\d*$/, "Please enter a valid number")
+        q.convert(:int, nil)
+      end
+      options[:limit] = limit_input if limit_input.present?
+
+      options[:format] = @prompt.select("Select report format:", %w[text json], default: "text")
+
+      options
+    end
 
     def display_header
       title = TTY::Box.frame(
@@ -85,7 +156,7 @@ module DbValidator
           }
         }
       )
-      puts title
+      Rails.logger.debug title
     end
   end
-end 
+end

data/lib/db_validator/configuration.rb

@@ -2,7 +2,7 @@
 
 module DbValidator
   class Configuration
-    attr_accessor :only_models, :ignored_models, :ignored_attributes, :batch_size, :report_format, :limit
+    attr_accessor :only_models, :ignored_models, :ignored_attributes, :batch_size, :report_format, :limit, :show_records
 
     def initialize
       @only_models = []
@@ -11,6 +11,7 @@ module DbValidator
       @batch_size = 1000
       @report_format = :text
       @limit = nil
+      @show_records = true
     end
 
     def only_models=(models)

data/lib/db_validator/formatters/json_formatter.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require "json"
+require "fileutils"
+
+module DbValidator
+  module Formatters
+    class JsonFormatter
+      def initialize(invalid_records)
+        @invalid_records = invalid_records
+      end
+
+      def format
+        formatted_data = @invalid_records.group_by { |r| r[:model] }.transform_values do |records|
+          {
+            error_count: records.length,
+            records: records.map { |r| format_record(r) }
+          }
+        end
+
+        save_to_file(formatted_data)
+        formatted_data.to_json
+      end
+
+      private
+
+      def format_record(record)
+        {
+          id: record[:id],
+          errors: record[:errors]
+        }
+      end
+
+      def save_to_file(data)
+        FileUtils.mkdir_p("db_validator_reports")
+        timestamp = Time.now.strftime("%Y%m%d_%H%M%S")
+        filename = "db_validator_reports/validation_report_#{timestamp}.json"
+
+        File.write(filename, JSON.pretty_generate(data))
+        Rails.logger.info "JSON report saved to #{filename}"
+      end
+    end
+  end
+end

data/lib/db_validator/reporter.rb

@@ -2,6 +2,7 @@
 
 require "tty-box"
 require "tty-spinner"
+require "db_validator/formatters/json_formatter"
 
 module DbValidator
   class Reporter
@@ -31,7 +32,7 @@ module DbValidator
     def generate_report
       case DbValidator.configuration.report_format
       when :json
-        generate_json_report
+        Formatters::JsonFormatter.new(@invalid_records).format
       else
         generate_text_report
       end
@@ -41,8 +42,7 @@ module DbValidator
 
     def format_value(value)
       case value
-      when true, false
-      when Symbol
+      when true, false, Symbol
         value.to_s
       when String
         "\"#{value}\""
@@ -55,7 +55,7 @@ module DbValidator
 
     def generate_text_report
       report = StringIO.new
-      
+
       title_box = TTY::Box.frame(
         width: 50,
         align: :center,
@@ -70,46 +70,51 @@ module DbValidator
       ) do
         "Database Validation Report"
       end
-      
+
       report.puts title_box
       report.puts
 
       if @invalid_records.empty?
-        report.puts "No invalid records found.".colorize(:green)
+        report.puts "No invalid records found."
       else
-        report.puts "Found #{@invalid_records.count} invalid records across #{@invalid_records.group_by { |r| r[:model] }.keys.count} models".colorize(:yellow)
+        is_plural = @invalid_records.count > 1
+        report.puts "Found #{@invalid_records.count} invalid #{is_plural ? 'records' : 'record'} across #{@invalid_records.group_by do |r|
+          r[:model]
+        end.keys.count} #{is_plural ? 'models' : 'model'}"
         report.puts
 
         @invalid_records.group_by { |r| r[:model] }.each do |model, records|
-          report.puts "#{model}: #{records.count} invalid records".colorize(:red)
+          report.puts "#{model}: #{records.count} invalid #{records.count == 1 ? 'record' : 'records'}"
+
+          next if DbValidator.configuration.show_records == false
+
           report.puts
 
           records.each do |record|
             record_obj = record[:model].constantize.find_by(id: record[:id])
-            next unless record_obj
 
             info = ["ID: #{record[:id]}"]
-            info << "Created: #{record_obj.created_at.strftime('%Y-%m-%d %H:%M:%S')}" if record_obj.respond_to?(:created_at)
-            info << "Updated: #{record_obj.updated_at.strftime('%Y-%m-%d %H:%M:%S')}" if record_obj.respond_to?(:updated_at)
+            if record_obj.respond_to?(:created_at)
+              info << "Created: #{record_obj.created_at.strftime('%Y-%m-%d %H:%M:%S')}"
+            end
+            if record_obj.respond_to?(:updated_at)
+              info << "Updated: #{record_obj.updated_at.strftime('%Y-%m-%d %H:%M:%S')}"
+            end
             info << "Name: #{record_obj.name}" if record_obj.respond_to?(:name)
             info << "Title: #{record_obj.title}" if record_obj.respond_to?(:title)
-            
-            report.puts "  #{info.join(' | ')}".colorize(:white)
+
+            report.puts "  #{info.join(' | ')}"
             record[:errors].each do |error|
-              report.puts "    ⚠️  #{error}".colorize(:white)
+              report.puts "    ⚠️  #{error}"
             end
             report.puts
           end
-          
+
           report.puts
         end
       end
 
       report.string
     end
-
-    def generate_json_report
-      @invalid_records.to_json
-    end
   end
 end

data/lib/db_validator/validator.rb

@@ -1,33 +1,62 @@
 # frozen_string_literal: true
 
 require "ruby-progressbar"
-require "colorize"
 
 module DbValidator
   class Validator
     attr_reader :reporter
 
     def initialize(options = {})
-      @options = options
-      @reporter = Reporter.new
       configure_from_options(options)
+      @reporter = Reporter.new
     end
 
     def validate_all
-      Rails.application.eager_load! if defined?(Rails)
+      models = get_models_to_validate
+      invalid_count = 0
 
-      models = find_all_models
-      models_to_validate = models.select { |model| should_validate_model?(model) }
-      total_models = models_to_validate.size
+      models.each do |model|
+        model_count = validate_model(model)
+        invalid_count += model_count if model_count
+      end
 
-      if models_to_validate.empty?
-        Rails.logger.debug "No models selected for validation.".colorize(:yellow)
-        return @reporter.generate_report
+      if invalid_count.zero?
+        Rails.logger.debug "\nValidation passed! All records are valid."
+      else
+        total_records = models.sum(&:count)
+        is_plural = invalid_count > 1
+        Rails.logger.debug do
+          "\nFound #{invalid_count} invalid #{is_plural ? 'records' : 'record'} out of #{total_records} total #{is_plural ? 'records' : 'record'}."
+        end
       end
 
-      models_to_validate.each_with_index do |model, index|
-        Rails.logger.debug "Validating model #{index + 1}/#{total_models}: #{model.name}".colorize(:cyan)
-        validate_model(model)
+      @reporter.generate_report
+    end
+
+    def validate_test_model(model_name)
+      model = model_name.constantize
+      scope = model.all
+      scope = scope.limit(DbValidator.configuration.limit) if DbValidator.configuration.limit
+
+      total_count = scope.count
+      progress_bar = create_progress_bar("Testing #{model.name}", total_count)
+      invalid_count = 0
+
+      begin
+        scope.find_each(batch_size: DbValidator.configuration.batch_size) do |record|
+          invalid_count += 1 unless validate_record(record)
+          progress_bar.increment
+        end
+      rescue StandardError => e
+        Rails.logger.debug { "Error validating #{model.name}: #{e.message}" }
+      end
+
+      if invalid_count.zero?
+        Rails.logger.debug "\nValidation rule passed! All records would be valid."
+      else
+        Rails.logger.debug do
+          "\nFound #{invalid_count} records that would become invalid out of #{total_count} total records."
+        end
       end
 
       @reporter.generate_report
@@ -38,13 +67,11 @@ module DbValidator
     def configure_from_options(options)
       return unless options.is_a?(Hash)
 
-      if options[:only_models]
-        DbValidator.configuration.only_models = Array(options[:only_models])
-      end
-      
+      DbValidator.configuration.only_models = Array(options[:only_models]) if options[:only_models]
       DbValidator.configuration.limit = options[:limit] if options[:limit]
       DbValidator.configuration.batch_size = options[:batch_size] if options[:batch_size]
       DbValidator.configuration.report_format = options[:report_format] if options[:report_format]
+      DbValidator.configuration.show_records = options[:show_records] if options[:show_records]
     end
 
     def find_all_models
@@ -59,37 +86,42 @@ module DbValidator
 
       config = DbValidator.configuration
       model_name = model.name.downcase
-      
+
       if config.only_models.any?
-        return config.only_models.map(&:downcase).include?(model_name)
+        return config.only_models.map(&:downcase).include?(model_name) ||
+               config.only_models.map(&:downcase).include?(model_name.singularize) ||
+               config.only_models.map(&:downcase).include?(model_name.pluralize)
       end
 
-      !config.ignored_models.map(&:downcase).include?(model_name)
+      config.ignored_models.map(&:downcase).exclude?(model_name)
     end
 
     def validate_model(model)
       config = DbValidator.configuration
-      batch_size = config.batch_size || 1000
+      batch_size = config.batch_size || 100
       limit = config.limit
 
       scope = model.all
       scope = scope.limit(limit) if limit
 
       total_count = scope.count
-      return if total_count.zero?
+      return 0 if total_count.zero?
 
       progress_bar = create_progress_bar(model.name, total_count)
+      invalid_count = 0
 
       begin
         scope.find_in_batches(batch_size: batch_size) do |batch|
           batch.each do |record|
-            validate_record(record)
+            invalid_count += 1 unless validate_record(record)
             progress_bar.increment
           end
         end
       rescue StandardError => e
-        Rails.logger.debug "Error validating #{model.name}: #{e.message}".colorize(:red)
+        Rails.logger.debug { "Error validating #{model.name}: #{e.message}" }
       end
+
+      invalid_count
     end
 
     def create_progress_bar(model_name, total)
@@ -102,8 +134,15 @@ module DbValidator
     end
 
     def validate_record(record)
-      return if record.valid?
+      return true if record.valid?
+
       @reporter.add_invalid_record(record)
+      false
+    end
+
+    def get_models_to_validate
+      models = find_all_models
+      models.select { |model| should_validate_model?(model) }
     end
   end
 end

data/lib/db_validator/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module DbValidator
-  VERSION = "0.2.0"
+  VERSION = "0.3.0"
 end

data/lib/generators/db_validator/templates/initializer.rb

@@ -13,9 +13,9 @@ DbValidator.configure do |config|
   #   "Post" => ["cached_votes"]
   # }
 
-  # Set the batch size for processing records (default: 1000)
-  # config.batch_size = 100
-
   # Set the report format (:text or :json)
   # config.report_format = :text
+
+  # Show detailed record information in reports
+  # config.show_records = true
 end

data/lib/tasks/db_validator_tasks.rake

@@ -1,29 +1,31 @@
 # frozen_string_literal: true
 
 namespace :db_validator do
-  desc "Validate all records in the database"
+  desc "Validate records in the database"
   task validate: :environment do
     cli = DbValidator::CLI.new
 
-    has_any_args = ENV["models"] || ENV["limit"] || ENV["batch_size"] || ENV["format"]
+    has_any_args = ENV["models"].present? || ENV["limit"].present? || ENV["format"].present? || ENV["show_records"].present?
 
     if has_any_args
-      models = ENV["models"].split(",").map(&:strip).map(&:downcase).map(&:singularize)
+      if ENV["models"].present?
+        models = ENV["models"].split(",").map(&:strip).map(&:classify)
+        DbValidator.configuration.only_models = models
+      end
 
-      DbValidator.configuration.only_models = models
       DbValidator.configuration.limit = ENV["limit"].to_i if ENV["limit"].present?
-      DbValidator.configuration.batch_size = ENV["batch_size"].to_i if ENV["batch_size"].present?
       DbValidator.configuration.report_format = ENV["format"].to_sym if ENV["format"].present?
+      DbValidator.configuration.show_records = ENV["show_records"] != "false" if ENV["show_records"].present?
     else
       cli.display_progress("Loading models") do
         Rails.application.eager_load!
       end
 
       available_models = ActiveRecord::Base.descendants
-        .reject(&:abstract_class?)
-        .select(&:table_exists?)
-        .map { |m| m.name }
-        .sort
+                                           .reject(&:abstract_class?)
+                                           .select(&:table_exists?)
+                                           .map(&:name)
+                                           .sort
 
       selected_models = cli.select_models(available_models)
       options = cli.configure_options
@@ -32,10 +34,62 @@ namespace :db_validator do
       DbValidator.configuration.limit = options[:limit] if options[:limit].present?
       DbValidator.configuration.batch_size = options[:batch_size] if options[:batch_size].present?
       DbValidator.configuration.report_format = options[:format].to_sym if options[:format].present?
+      DbValidator.configuration.show_records = options[:show_records] if options[:show_records].present?
     end
 
     validator = DbValidator::Validator.new
     report = validator.validate_all
     puts "\n#{report}"
   end
+
+  desc "Test validation rules on existing records"
+  task test: :environment do
+    unless ENV["model"] && ENV["rule"]
+      puts "Usage: rake db_validator:test model=user rule='validates :field, presence: true' [show_records=false] [limit=1000] [format=json]"
+      exit 1
+    end
+
+    model_name = ENV.fetch("model").classify
+    validation_rule = ENV.fetch("rule", nil)
+
+    # Configure options
+    DbValidator.configuration.show_records = ENV["show_records"] != "false" if ENV["show_records"].present?
+    DbValidator.configuration.limit = ENV["limit"].to_i if ENV["limit"].present?
+    DbValidator.configuration.report_format = ENV["format"].to_sym if ENV["format"].present?
+
+    begin
+      base_model = model_name.constantize
+      # Extract attribute name from validation rule
+      attribute_match = validation_rule.match(/validates\s+:(\w+)/)
+      if attribute_match
+        attribute_name = attribute_match[1]
+        unless base_model.column_names.include?(attribute_name) || base_model.method_defined?(attribute_name)
+          puts "\n❌ Error: Attribute '#{attribute_name}' does not exist for model '#{model_name}'"
+          puts "Available columns: #{base_model.column_names.join(', ')}"
+          exit 1
+        end
+      end
+
+      # Create temporary subclass with new validation
+      temp_model = Class.new(base_model) do
+        self.table_name = base_model.table_name
+        class_eval(validation_rule)
+      end
+
+      Object.const_set("Temporary#{model_name}", temp_model)
+
+      validator = DbValidator::Validator.new
+      report = validator.validate_test_model("Temporary#{model_name}")
+      puts "\n#{report}"
+    rescue NameError
+      puts "\n❌ Error: Model '#{model_name}' not found"
+      exit 1
+    rescue SyntaxError => e
+      puts "\n❌ Error: Invalid validation rule syntax"
+      puts e.message
+      exit 1
+    ensure
+      Object.send(:remove_const, "Temporary#{model_name}") if Object.const_defined?("Temporary#{model_name}")
+    end
+  end
 end

data/readme.md

@@ -26,6 +26,7 @@ $ bundle install
 The simplest way to run validation is using the provided rake task:
 
 #### Validate models in interactive mode
+
 <img width="798" alt="Screenshot 2024-11-07 at 21 50 57" src="https://github.com/user-attachments/assets/33fbdb8b-b8ec-4284-9313-c1eeaf2eab2d">
 
 ```bash
@@ -52,12 +53,37 @@ $ rake db_validator:validate limit=1000
 $ rake db_validator:validate format=json
 ```
 
-### Interactive Mode
+### Test Mode
 
-Running the validation task without specifying models will start an interactive mode:
+You can test new validation rules before applying them to your models:
 
 ```bash
-$ rake db_validator:validate
+$ rake db_validator:test model=User rule='validates :name, presence: true'
+```
+
+#### Testing Email Format Validation
+
+Here's an example of testing email format validation rules:
+
+```bash
+# Testing invalid email format (without @)
+$ rake db_validator:test model=User rule='validates :email, format: { without: /@/, message: "must contain @" }'
+
+Found 100 records that would become invalid out of 100 total records.
+
+# Testing valid email format (with @)
+$ rake db_validator:test model=User rule='validates :email, format: { with: /@/, message: "must contain @" }'
+
+No invalid records found.
+```
+
+#### Error Handling
+
+Trying to test a validation rule for a non-existent attribute will return an error:
+
+```
+❌ Error: Attribute 'i_dont_exist' does not exist for model 'User'
+Available columns: id, email, created_at, updated_at, name
 ```
 
 ### Ruby Code
@@ -103,17 +129,26 @@ ID: 5
 
 ### JSON Format
 
+The JSON report is saved to a file in the `db_validator_reports` directory.
+
 ```json
-[
-  {
-    "model": "User",
-    "id": 1,
-    "errors": ["email is invalid (actual value: \"invalid-email\")"]
-  },
-  {
-    "model": "User",
-    "id": 2,
-    "errors": ["name can't be blank (actual value: \"\")"]
+{
+  "User": {
+    "error_count": 2,
+    "records": [
+      {
+        "id": 1,
+        "errors": [
+          "email is invalid (actual value: \"invalid-email\")"
+        ]
+      },
+      {
+        "id": 2,
+        "errors": [
+          "name can't be blank (actual value: \"\")"
+        ]
+      }
+    ]
   }
-]
+}
 ```

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: db_validator
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Krzysztof Duda
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-11-07 00:00:00.000000000 Z
+date: 2024-11-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -66,20 +66,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.4'
-- !ruby/object:Gem::Dependency
-  name: colorize
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.8.1
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.8.1
 - !ruby/object:Gem::Dependency
   name: ruby-progressbar
   requirement: !ruby/object:Gem::Requirement
@@ -95,33 +81,33 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '1.11'
 - !ruby/object:Gem::Dependency
-  name: tty-prompt
+  name: tty-box
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.23.1
+        version: 0.7.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.23.1
+        version: 0.7.0
 - !ruby/object:Gem::Dependency
-  name: tty-box
+  name: tty-prompt
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.7.0
+        version: 0.23.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.7.0
+        version: 0.23.1
 - !ruby/object:Gem::Dependency
   name: tty-spinner
   requirement: !ruby/object:Gem::Requirement
@@ -151,6 +137,7 @@ files:
 - lib/db_validator.rb
 - lib/db_validator/cli.rb
 - lib/db_validator/configuration.rb
+- lib/db_validator/formatters/json_formatter.rb
 - lib/db_validator/railtie.rb
 - lib/db_validator/reporter.rb
 - lib/db_validator/validator.rb
@@ -163,6 +150,9 @@ homepage: https://github.com/krzysztoff1/db-validator
 licenses:
 - MIT
 metadata:
+  source_code_uri: https://github.com/krzysztoff1/db-validator/
+  documentation_uri: https://github.com/krzysztoff1/db-validator/blob/main/README.md
+  changelog_uri: https://github.com/krzysztoff1/db-validator/blob/main/changelog.md
   rubygems_mfa_required: 'true'
 post_install_message:
 rdoc_options: []
@@ -179,7 +169,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.16
+rubygems_version: 3.5.9
 signing_key:
 specification_version: 4
 summary: DbValidator helps identify invalid records in your Rails application that