db_validator 0.2.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 60cba1d36771e30b0bafb5ac354f3d741b3bde0e5f37b267bcff4ebb9dd11bad
-  data.tar.gz: 1baa177ce745a107d5c064844b74cd8731b5cddd8624f2944c464812c9e136b0
+  metadata.gz: 130796e31968cc4d325f42092eb82f8e21a67c56fdfc751116f354f6998c93f5
+  data.tar.gz: e4ec35da042e41699b25e607f642d9208564bf49f88f99be191029756f1e7f96
 SHA512:
-  metadata.gz: d3e414c08cf3496438f5a61941c579b072dd9a41330133df64bfe48c3e8d205cf3de933f52368622d3cd7cbcea8cea5844982f7fb95bf1eafca59bcb1b6f781a
-  data.tar.gz: 9a2d9de68775b836aec350ded2b88184c534e3dac4649d6b531e5f5575363f30ee60b1a10a9439cfbd2beb083ea2036a095a17d37c5593d9fe4e730bdb7349fe
+  metadata.gz: 6cdeaf577ff2b53836dca41616b8c90fb0bdce77d0e8e8d456fcb1fc3889ae02373b72cf70df4829c77d22f3ef0217f211c02a39b779d3a06fdfd2aaba66c085
+  data.tar.gz: b1abf3df297599475a5876aef7fed5a4e6c304f5175ed686c003ee75214c08f87755a5c5fa7825a8171d37af495723e0d357c8e56511ca358190f998f4498dad

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."
+        raise "No models found in the application. Please run this command from your Rails application root."
+      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."
+      raise "Rails application not found. Please run this command from your Rails application root."
     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/config_updater.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module DbValidator
+  class ConfigUpdater
+    def self.update_from_env
+      new.update_from_env
+    end
+
+    def self.update_from_options(options)
+      new.update_from_options(options)
+    end
+
+    def update_from_env
+      update_config(
+        limit: ENV["limit"]&.to_i,
+        report_format: ENV["format"]&.to_sym,
+        show_records: ENV["show_records"] != "false"
+      )
+    end
+
+    def update_from_options(options)
+      update_config(
+        limit: options[:limit],
+        batch_size: options[:batch_size],
+        report_format: options[:format]&.to_sym,
+        show_records: options[:show_records]
+      )
+    end
+
+    private
+
+    def update_config(settings)
+      settings.each do |key, value|
+        next unless value
+
+        DbValidator.configuration.public_send("#{key}=", value)
+      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.zone.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/formatters/message_formatter.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module DbValidator
+  module Formatters
+    class MessageFormatter
+      def initialize(record)
+        @record = record
+      end
+
+      def format_error_message(error, field_value, message)
+        return enum_validation_message(error, field_value, message) if error.options[:in].present?
+        return enum_field_message(error, field_value, message) if enum_field?(error)
+
+        basic_validation_message(error, field_value, message)
+      end
+
+      private
+
+      attr_reader :record
+
+      def enum_validation_message(error, field_value, message)
+        allowed = error.options[:in].join(", ")
+        error_message = "#{error.attribute} #{message}"
+        details = " (allowed values: #{allowed}, actual value: #{field_value.inspect})"
+
+        "#{error_message} #{details}"
+      end
+
+      def enum_field_message(error, field_value, message)
+        enum_values = record.class.defined_enums[error.attribute.to_s].keys
+        error_message = "#{error.attribute} #{message}"
+        details = " (allowed values: #{enum_values.join(', ')}, actual value: #{field_value.inspect})"
+
+        "#{error_message} #{details}"
+      end
+
+      def enum_field?(error)
+        record.class.defined_enums[error.attribute.to_s].present?
+      end
+
+      def basic_validation_message(error, field_value, message)
+        "#{error.attribute} #{message} (actual value: #{format_value(field_value)})"
+      end
+
+      def format_value(value)
+        case value
+        when true, false, Symbol
+          value.to_s
+        when String
+          "\"#{value}\""
+        when nil
+          "nil"
+        else
+          value
+        end
+      end
+    end
+  end
+end

data/lib/db_validator/reporter.rb

@@ -2,6 +2,8 @@
 
 require "tty-box"
 require "tty-spinner"
+require "db_validator/formatters/json_formatter"
+require "db_validator/formatters/message_formatter"
 
 module DbValidator
   class Reporter
@@ -10,15 +12,11 @@ module DbValidator
     end
 
     def add_invalid_record(record)
+      formatter = Formatters::MessageFormatter.new(record)
       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: #{format_value(field_value)})"
-        end
+        formatter.format_error_message(error, field_value, message)
       end
 
       @invalid_records << {
@@ -28,10 +26,15 @@ module DbValidator
       }
     end
 
+    def generate_report_message(error, field_value, message)
+      formatter = Formatters::MessageFormatter.new(record)
+      formatter.format_error_message(error, field_value, message)
+    end
+
     def generate_report
       case DbValidator.configuration.report_format
       when :json
-        generate_json_report
+        Formatters::JsonFormatter.new(@invalid_records).format
       else
         generate_text_report
       end
@@ -39,23 +42,81 @@ module DbValidator
 
     private
 
-    def format_value(value)
-      case value
-      when true, false
-      when Symbol
-        value.to_s
-      when String
-        "\"#{value}\""
-      when nil
-        "nil"
-      else
-        value
+    def generate_text_report
+      print_title
+
+      report = StringIO.new
+
+      if @invalid_records.empty?
+        report.puts "No invalid records found."
+        return report.string
+      end
+
+      report.puts print_summary
+      report.puts
+
+      @invalid_records.group_by { |r| r[:model] }.each do |model, records|
+        report.puts generate_model_report(model, records)
       end
+
+      report.string
     end
 
-    def generate_text_report
+    def print_summary
+      report = StringIO.new
+      is_plural = @invalid_records.count > 1
+      record_word = is_plural ? "records" : "record"
+      model_word = is_plural ? "models" : "model"
+
+      report.puts "Found #{@invalid_records.count} invalid #{record_word} across #{@invalid_records.group_by do |r|
+        r[:model]
+      end.keys.count} #{model_word}"
+
+      report.string
+    end
+
+    def generate_model_report(model, records)
+      report = StringIO.new
+      report.puts
+      report.puts "#{model}: #{records.count} invalid #{records.count == 1 ? 'record' : 'records'}"
+      report.puts
+
+      records.each_with_index do |record, index|
+        report.puts generate_record_report(record, index)
+      end
+
+      report.string
+    end
+
+    def generate_record_report(record, index) # rubocop:disable Metrics/AbcSize
       report = StringIO.new
-      
+
+      record_obj = record[:model].constantize.find_by(id: record[:id])
+      info = []
+      info << "Record ##{index + 1}"
+      info << "ID: #{record[:id]}"
+
+      # Add timestamps if available
+      if record_obj.respond_to?(:created_at)
+        info << "Created: #{record_obj.created_at.strftime('%b %d, %Y at %I:%M %p')}"
+      end
+      if record_obj.respond_to?(:updated_at)
+        info << "Updated: #{record_obj.updated_at.strftime('%b %d, %Y at %I:%M %p')}"
+      end
+
+      # Add identifying fields if available
+      info << "Name: #{record_obj.name}" if record_obj.respond_to?(:name) && record_obj.name.present?
+      info << "Title: #{record_obj.title}" if record_obj.respond_to?(:title) && record_obj.title.present?
+
+      report.puts "  #{info.join(', ')}"
+      record[:errors].each do |error|
+        report.puts "    \e[31m- #{error}\e[0m"
+      end
+
+      report.string
+    end
+
+    def print_title
       title_box = TTY::Box.frame(
         width: 50,
         align: :center,
@@ -70,46 +131,10 @@ 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)
-      else
-        report.puts "Found #{@invalid_records.count} invalid records across #{@invalid_records.group_by { |r| r[:model] }.keys.count} models".colorize(:yellow)
-        report.puts
-
-        @invalid_records.group_by { |r| r[:model] }.each do |model, records|
-          report.puts "#{model}: #{records.count} invalid records".colorize(:red)
-          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)
-            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)
-            record[:errors].each do |error|
-              report.puts "    ⚠️  #{error}".colorize(:white)
-            end
-            report.puts
-          end
-          
-          report.puts
-        end
-      end
-
-      report.string
-    end
 
-    def generate_json_report
-      @invalid_records.to_json
+      puts
+      puts title_box
+      puts
     end
   end
 end

data/lib/db_validator/test_task.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module DbValidator
+  class TestTask
+    def initialize(model_name, validation_rule)
+      @model_name = model_name
+      @validation_rule = validation_rule
+    end
+
+    def execute
+      validate_and_test_model
+    rescue NameError
+      puts "Model '#{@model_name}' not found"
+      raise "Model '#{@model_name}' not found"
+    rescue SyntaxError
+      puts "Invalid validation rule syntax"
+      raise "Invalid validation rule syntax"
+    ensure
+      cleanup_temporary_model
+    end
+
+    private
+
+    def validate_and_test_model
+      base_model = @model_name.constantize
+      validate_attribute(base_model)
+
+      temp_model = create_temporary_model(base_model)
+      Object.const_set("Temporary#{@model_name}", temp_model)
+
+      validator = DbValidator::Validator.new
+      report = validator.validate_test_model("Temporary#{@model_name}")
+      puts report
+    end
+
+    def validate_attribute(base_model)
+      attribute_match = @validation_rule.match(/validates\s+:(\w+)/)
+      return unless attribute_match
+
+      attribute_name = attribute_match[1]
+      return if base_model.column_names.include?(attribute_name) || base_model.method_defined?(attribute_name)
+
+      puts "Attribute '#{attribute_name}' does not exist for model '#{@model_name}'"
+      raise "Attribute '#{attribute_name}' does not exist for model '#{@model_name}'"
+    end
+
+    def create_temporary_model(base_model)
+      Class.new(base_model) do
+        self.table_name = base_model.table_name
+        class_eval(@validation_rule)
+      end
+    end
+
+    def cleanup_temporary_model
+      temp_const_name = "Temporary#{@model_name}"
+      Object.send(:remove_const, temp_const_name) if Object.const_defined?(temp_const_name)
+    end
+  end
+end

data/lib/db_validator/validate_task.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module DbValidator
+  class ValidateTask
+    def initialize(cli = DbValidator::CLI.new)
+      @cli = cli
+    end
+
+    def execute
+      configure_from_env_or_cli
+      run_validation
+    end
+
+    private
+
+    def configure_from_env_or_cli
+      if env_args_present?
+        configure_from_env
+      else
+        configure_from_cli
+      end
+    end
+
+    def env_args_present?
+      ENV["models"].present? || ENV["limit"].present? ||
+        ENV["format"].present? || ENV["show_records"].present?
+    end
+
+    def configure_from_env
+      if ENV["models"].present?
+        models = ENV["models"].split(",").map(&:strip).map(&:classify)
+        DbValidator.configuration.only_models = models
+      end
+
+      ConfigUpdater.update_from_env
+    end
+
+    def configure_from_cli
+      @cli.display_progress("Loading models") { Rails.application.eager_load! }
+
+      available_models = ActiveRecord::Base.descendants
+                                           .reject(&:abstract_class?)
+                                           .select(&:table_exists?)
+                                           .map(&:name)
+                                           .sort
+
+      selected_models = @cli.select_models(available_models)
+      options = @cli.configure_options
+
+      DbValidator.configuration.only_models = selected_models
+      ConfigUpdater.update_from_options(options)
+    end
+
+    def run_validation
+      validator = DbValidator::Validator.new
+      report = validator.validate_all
+      puts report
+    end
+  end
+end

data/lib/db_validator/validator.rb

@@ -1,33 +1,68 @@
 # 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 = 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 invalid_count.zero?
+        Rails.logger.debug "\nValidation passed! All records are valid."
+      else
+        total_records = models.sum(&:count)
+        Rails.logger.debug get_summary(total_records, invalid_count)
+      end
+
+      @reporter.generate_report
+    end
+
+    def get_summary(records_count, invalid_count)
+      is_plural = invalid_count > 1
+      records_word = is_plural ? "records" : "record"
+      first_part = "\nFound #{invalid_count} invalid #{records_word} out of #{records_count} total #{records_word}."
+      second_part = "\nValidation failed! Some records are invalid." if invalid_count.positive?
 
-      if models_to_validate.empty?
-        Rails.logger.debug "No models selected for validation.".colorize(:yellow)
-        return @reporter.generate_report
+      "#{first_part} #{second_part}"
+    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
 
-      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
@@ -38,13 +73,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 +92,57 @@ 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
-      limit = config.limit
+      scope = build_scope(model)
+      total_count = scope.count
+      return 0 if total_count.zero?
 
-      scope = model.all
-      scope = scope.limit(limit) if limit
+      process_records(scope, model, total_count)
+    end
 
-      total_count = scope.count
-      return if total_count.zero?
+    def build_scope(model)
+      scope = model.all
+      scope = scope.limit(DbValidator.configuration.limit) if DbValidator.configuration.limit
+      scope
+    end
 
+    def process_records(scope, model, total_count)
       progress_bar = create_progress_bar(model.name, total_count)
+      process_batches(scope, progress_bar, model)
+    end
+
+    def process_batches(scope, progress_bar, model)
+      invalid_count = 0
+      batch_size = DbValidator.configuration.batch_size || 100
 
       begin
         scope.find_in_batches(batch_size: batch_size) do |batch|
-          batch.each do |record|
-            validate_record(record)
-            progress_bar.increment
-          end
+          invalid_count += process_batch(batch, progress_bar)
         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 process_batch(batch, progress_bar)
+      invalid_count = 0
+      batch.each do |record|
+        invalid_count += 1 unless validate_record(record)
+        progress_bar.increment
       end
+      invalid_count
     end
 
     def create_progress_bar(model_name, total)
@@ -102,8 +155,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 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 = "1.0.0"
 end

data/lib/db_validator.rb

@@ -6,6 +6,9 @@ require "db_validator/configuration"
 require "db_validator/validator"
 require "db_validator/reporter"
 require "db_validator/cli"
+require "db_validator/config_updater"
+require "db_validator/test_task"
+require "db_validator/validate_task"
 
 module DbValidator
   class Error < StandardError; 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,41 +1,25 @@
 # 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"]
-
-    if has_any_args
-      models = ENV["models"].split(",").map(&:strip).map(&:downcase).map(&:singularize)
-
-      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?
-    else
-      cli.display_progress("Loading models") do
-        Rails.application.eager_load!
-      end
+    DbValidator::ValidateTask.new.execute
+  end
 
-      available_models = ActiveRecord::Base.descendants
-        .reject(&:abstract_class?)
-        .select(&:table_exists?)
-        .map { |m| m.name }
-        .sort
+  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]"
+      raise "No models found in the application. Please run this command from your Rails application root."
+    end
 
-      selected_models = cli.select_models(available_models)
-      options = cli.configure_options
+    model_name = ENV.fetch("model").classify
+    validation_rule = ENV.fetch("rule", nil)
 
-      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?
-    end
+    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?
 
-    validator = DbValidator::Validator.new
-    report = validator.validate_all
-    puts "\n#{report}"
+    DbValidator::TestTask.new(model_name, validation_rule).execute
   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: 1.0.0
 platform: ruby
 authors:
 - Krzysztof Duda
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-11-07 00:00:00.000000000 Z
+date: 2024-12-13 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
@@ -150,9 +136,14 @@ files:
 - config/initializers/db_validator.rb
 - lib/db_validator.rb
 - lib/db_validator/cli.rb
+- lib/db_validator/config_updater.rb
 - lib/db_validator/configuration.rb
+- lib/db_validator/formatters/json_formatter.rb
+- lib/db_validator/formatters/message_formatter.rb
 - lib/db_validator/railtie.rb
 - lib/db_validator/reporter.rb
+- lib/db_validator/test_task.rb
+- lib/db_validator/validate_task.rb
 - lib/db_validator/validator.rb
 - lib/db_validator/version.rb
 - lib/generators/db_validator/install_generator.rb
@@ -163,6 +154,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 +173,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