db_validator 0.1.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d5b1e93e6a494c74779345e004eb7f6050fa5fd4e15cb27846d48fa8390a78ef
-  data.tar.gz: 9ab575840ad1cb722db62b40162b527e4793305ed4255b38eb1166ba5e4786fe
+  metadata.gz: 527983d42b2851e593a40202407ff01d8b82cb13c97741239307d21a12416567
+  data.tar.gz: 389a234732560ec7f0fcf1ba9c0bb995d9552a842719d75f20569b9d7f86818e
 SHA512:
-  metadata.gz: 20cc83d66461dff7faed7ec1eee28b4c5459152d723403c15b23718554e5ae208e965acde7b3ee4bb2ba030e19bdd86c1e4e63bd0072e7e2bfbfdd25048647e9
-  data.tar.gz: b8e9a4175498cf0f96eec2ed624a9c1be35c6092206bfd7117ecad929f59760236d361cbf524cce37fb603feaafa4ed981f5cbf0308cb0b79a2b2adb2c39a5d5
+  metadata.gz: e4cec830738a0de711477620603757c2fade101075d64a9cbf824ecef806a994c7e0da655add3f495e2ac828a15a3e2b7db0143e32718a6aebbfa3fa3911fc70
+  data.tar.gz: e3a6d02dd6ce60e17e0ecdf5a255d0fe9886fc7533e0ad8c7334c0f3d0c03970c0aa4b01bdd90fa8342c3cb4225816b3a3658908e2e23e2ccfae2aa8fd1fc286

data/config/initializers/db_validator.rb

@@ -2,7 +2,7 @@
 
 DbValidator.configure do |config|
   config.only_models = %w[Documents Users]
-  config.batch_size = 500
+  config.batch_size = 100
   config.limit = 500
   config.model_limits = {
     "documents" => 500,

data/lib/db_validator/cli.rb

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+
+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)
+      system "clear"
+      display_header
+
+      if available_models.empty?
+        @prompt.error("No models found in the application.")
+        exit
+      end
+
+      choices = available_models.map { |model| { name: model, value: model } }
+      choices.unshift({ name: "All Models", value: "all" })
+
+      @prompt.say("\n")
+      selected = @prompt.multi_select(
+        "Select models to validate:",
+        choices,
+        per_page: 10,
+        echo: false,
+        show_help: :always,
+        filter: true,
+        cycle: true
+      )
+
+      if selected.include?("all")
+        available_models
+      else
+        selected
+      end
+    end
+
+    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
+      end
+    end
+
+    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
+
+    def interactive_mode
+      load_rails
+      display_header
+
+      display_progress("Loading models") do
+        Rails.application.eager_load!
+      end
+
+      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 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
+
+    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(
+        "DB Validator",
+        "Interactive Model Validation",
+        padding: 1,
+        align: :center,
+        border: :thick,
+        style: {
+          border: {
+            fg: :cyan
+          }
+        }
+      )
+      Rails.logger.debug title
+    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, :auto_fix, :limit
+    attr_accessor :only_models, :ignored_models, :ignored_attributes, :batch_size, :report_format, :limit, :show_records
 
     def initialize
       @only_models = []
@@ -10,8 +10,8 @@ module DbValidator
       @ignored_attributes = {}
       @batch_size = 1000
       @report_format = :text
-      @auto_fix = false
       @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

@@ -1,5 +1,9 @@
 # frozen_string_literal: true
 
+require "tty-box"
+require "tty-spinner"
+require "db_validator/formatters/json_formatter"
+
 module DbValidator
   class Reporter
     def initialize
@@ -10,11 +14,11 @@ module DbValidator
       enhanced_errors = record.errors.map do |error|
         field_value = record.send(error.attribute)
         message = error.message
-        
+
         if error.options[:in].present?
           "#{error.attribute} #{message} (allowed values: #{error.options[:in].join(', ')}, actual value: #{field_value.inspect})"
         else
-          "#{error.attribute} #{message} (actual value: #{field_value.inspect})"
+          "#{error.attribute} #{message} (actual value: #{format_value(field_value)})"
         end
       end
 
@@ -28,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
@@ -36,35 +40,81 @@ module DbValidator
 
     private
 
+    def format_value(value)
+      case value
+      when true, false, Symbol
+        value.to_s
+      when String
+        "\"#{value}\""
+      when nil
+        "nil"
+      else
+        value
+      end
+    end
+
     def generate_text_report
       report = StringIO.new
-      report.puts "DbValidator Report"
-      report.puts "=================="
+
+      title_box = TTY::Box.frame(
+        width: 50,
+        align: :center,
+        padding: [1, 2],
+        title: { top_left: "DbValidator" },
+        style: {
+          fg: :cyan,
+          border: {
+            fg: :cyan
+          }
+        }
+      ) do
+        "Database Validation Report"
+      end
+
+      report.puts title_box
       report.puts
 
       if @invalid_records.empty?
         report.puts "No invalid records found."
       else
-        report.puts "Found invalid records:"
+        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"
+          report.puts "#{model}: #{records.count} invalid #{records.count == 1 ? 'record' : 'records'}"
+
+          next if DbValidator.configuration.show_records == false
+
+          report.puts
+
           records.each do |record|
-            report.puts "  ID: #{record[:id]}"
+            record_obj = record[:model].constantize.find_by(id: record[:id])
+
+            info = ["ID: #{record[:id]}"]
+            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(' | ')}"
             record[:errors].each do |error|
-              report.puts "    - #{error}"
+              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,27 +1,62 @@
 # frozen_string_literal: true
 
 require "ruby-progressbar"
-require "colorize"
 
 module DbValidator
   class Validator
+    attr_reader :reporter
+
     def initialize(options = {})
-      @options = options
+      configure_from_options(options)
       @reporter = Reporter.new
-      @fixer = Fixer.new if DbValidator.configuration.auto_fix
     end
 
     def validate_all
-      Rails.application.eager_load! if defined?(Rails)
+      models = get_models_to_validate
+      invalid_count = 0
 
-      models = find_all_models
+      models.each do |model|
+        model_count = validate_model(model)
+        invalid_count += model_count if model_count
+      end
+
+      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
+
+      @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
 
-      models_to_validate = models.select { |model| should_validate_model?(model) }
-      total_models = models_to_validate.size
+      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
 
-      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)
+      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
@@ -29,8 +64,17 @@ module DbValidator
 
     private
 
+    def configure_from_options(options)
+      return unless options.is_a?(Hash)
+
+      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
-      # Include all classes inheriting from ActiveRecord::Base
       ObjectSpace.each_object(Class).select do |klass|
         klass < ActiveRecord::Base
       end
@@ -42,45 +86,63 @@ module DbValidator
 
       config = DbValidator.configuration
       model_name = model.name.downcase
-      return config.only_models.include?(model_name) if config.only_models.any?
 
-      config.ignored_models.exclude?(model_name)
+      if config.only_models.any?
+        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).exclude?(model_name)
     end
 
     def validate_model(model)
-      limit = DbValidator.configuration.limit
-      total_records = limit || model.count
+      config = DbValidator.configuration
+      batch_size = config.batch_size || 100
+      limit = config.limit
 
-      if total_records.zero?
-        Rails.logger.debug { "No records to validate for model #{model.name}." }
-        return
-      end
+      scope = model.all
+      scope = scope.limit(limit) if limit
 
-      processed_records = 0
+      total_count = scope.count
+      return 0 if total_count.zero?
 
-      query = model.all
-      query = query.limit(limit) if limit
+      progress_bar = create_progress_bar(model.name, total_count)
+      invalid_count = 0
 
-      query.find_in_batches(batch_size: DbValidator.configuration.batch_size) do |batch|
-        batch.each do |record|
-          validate_record(record)
-          processed_records += 1
-          if (processed_records % 100).zero? || processed_records == total_records
-            Rails.logger.debug "Validated #{processed_records}/#{total_records} records for model #{model.name}".colorize(:green)
+      begin
+        scope.find_in_batches(batch_size: batch_size) do |batch|
+          batch.each do |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
-    rescue ActiveRecord::StatementInvalid => e
-      Rails.logger.debug { "Skipping validation for #{model.name}: #{e.message}" }
+
+      invalid_count
+    end
+
+    def create_progress_bar(model_name, total)
+      ProgressBar.create(
+        title: "Validating #{model_name}",
+        total: total,
+        format: "%t: |%B| %p%% %e",
+        output: $stderr
+      )
     end
 
     def validate_record(record)
-      return if record.valid?
+      return true if record.valid?
 
       @reporter.add_invalid_record(record)
-      @fixer&.attempt_fix(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.1.0"
+  VERSION = "0.3.0"
 end

data/lib/db_validator.rb

@@ -5,7 +5,7 @@ require "db_validator/version"
 require "db_validator/configuration"
 require "db_validator/validator"
 require "db_validator/reporter"
-require "db_validator/fixer"
+require "db_validator/cli"
 
 module DbValidator
   class Error < StandardError; end

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

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

data/lib/tasks/db_validator_tasks.rake

@@ -1,19 +1,95 @@
 # 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
-    if ENV["models"]
-      models = ENV["models"].split(",").map(&:strip).map(&:downcase)
-      DbValidator.configuration.only_models = models
-    end
+    cli = DbValidator::CLI.new
+
+    has_any_args = ENV["models"].present? || ENV["limit"].present? || ENV["format"].present? || ENV["show_records"].present?
+
+    if has_any_args
+      if ENV["models"].present?
+        models = ENV["models"].split(",").map(&:strip).map(&:classify)
+        DbValidator.configuration.only_models = models
+      end
+
+      DbValidator.configuration.limit = ENV["limit"].to_i if ENV["limit"].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
 
-    DbValidator.configuration.limit = ENV["limit"].to_i if ENV["limit"]
+      available_models = ActiveRecord::Base.descendants
+                                           .reject(&:abstract_class?)
+                                           .select(&:table_exists?)
+                                           .map(&:name)
+                                           .sort
 
-    DbValidator.configuration.report_format = ENV["format"].to_sym if ENV["format"]
+      selected_models = cli.select_models(available_models)
+      options = cli.configure_options
+
+      DbValidator.configuration.only_models = selected_models
+      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 report
+    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

@@ -1,6 +1,9 @@
+[![Gem Version](https://badge.fury.io/rb/db_validator.svg?icon=si%3Arubygems)](https://badge.fury.io/rb/db_validator)
+[![RSpec Tests](https://github.com/krzysztoff1/db-validator/actions/workflows/rspec.yml/badge.svg)](https://github.com/krzysztoff1/db-validator/actions/workflows/rspec.yml)
+
 # DbValidator
 
-DbValidator helps identify invalid records in your Rails application that don't meet model validation requirements.
+DbValidator helps identify invalid records in your Rails application that don't meet model validation requirements. It finds records that became invalid after validation rule changes, and validates imported or manually edited data. You can use it to audit records before deploying new validations and catch any data that bypassed validation checks.
 
 ## Installation
 
@@ -16,24 +19,22 @@ Then execute:
 $ bundle install
 ```
 
-Or install it yourself:
-
-```bash
-$ gem install db_validator
-```
-
 ## Usage
 
 ### Rake Task
 
 The simplest way to run validation is using the provided rake task:
 
-#### Validate all models
+#### 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
 $ rake db_validator:validate
 ```
 
+This will start an interactive mode where you can select which models to validate and adjust other options.
+
 #### Validate specific models
 
 ```bash
@@ -52,6 +53,39 @@ $ rake db_validator:validate limit=1000
 $ rake db_validator:validate format=json
 ```
 
+### Test Mode
+
+You can test new validation rules before applying them to your models:
+
+```bash
+$ 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
 
 You can also run validation from your Ruby code:
@@ -95,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.1.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
@@ -67,35 +67,66 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '1.4'
 - !ruby/object:Gem::Dependency
-  name: colorize
+  name: ruby-progressbar
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.8.1
+        version: '1.11'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.8.1
+        version: '1.11'
 - !ruby/object:Gem::Dependency
-  name: ruby-progressbar
+  name: tty-box
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.11'
+        version: 0.7.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.11'
-description: A comprehensive solution for validating existing database records in
-  Rails applications
+        version: 0.7.0
+- !ruby/object:Gem::Dependency
+  name: tty-prompt
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.23.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.23.1
+- !ruby/object:Gem::Dependency
+  name: tty-spinner
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.3
+description: DbValidator helps identify invalid records in your Rails application
+  that don't meet model validation requirements. It finds records that became invalid
+  after validation rule changes, and validates imported or manually edited data. You
+  can use it to audit records before deploying new validations and catch any data
+  that bypassed validation checks.
 email:
 - duda_krzysztof@outlook.com
 executables: []
@@ -104,8 +135,9 @@ extra_rdoc_files: []
 files:
 - config/initializers/db_validator.rb
 - lib/db_validator.rb
+- lib/db_validator/cli.rb
 - lib/db_validator/configuration.rb
-- lib/db_validator/fixer.rb
+- lib/db_validator/formatters/json_formatter.rb
 - lib/db_validator/railtie.rb
 - lib/db_validator/reporter.rb
 - lib/db_validator/validator.rb
@@ -114,10 +146,13 @@ files:
 - lib/generators/db_validator/templates/initializer.rb
 - lib/tasks/db_validator_tasks.rake
 - readme.md
-homepage: https://github.com/yourusername/db_validator
+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: []
@@ -134,8 +169,9 @@ 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: Database-wide validation for Rails applications
+summary: DbValidator helps identify invalid records in your Rails application that
+  don't meet model validation requirements
 test_files: []

data/lib/db_validator/fixer.rb

@@ -1,35 +0,0 @@
-# frozen_string_literal: true
-
-module DbValidator
-  class Fixer
-    def initialize
-      @fixed_records = 0
-      @failed_fixes = 0
-    end
-
-    def fix_record(record)
-      return false unless record.invalid?
-
-      success = attempt_fix(record)
-      if success
-        @fixed_records += 1
-      else
-        @failed_fixes += 1
-      end
-      success
-    end
-
-    def statistics
-      {
-        fixed_records: @fixed_records,
-        failed_fixes: @failed_fixes
-      }
-    end
-
-    private
-
-    def attempt_fix(record)
-      record.save
-    end
-  end
-end