db_validator 0.3.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 527983d42b2851e593a40202407ff01d8b82cb13c97741239307d21a12416567
-  data.tar.gz: 389a234732560ec7f0fcf1ba9c0bb995d9552a842719d75f20569b9d7f86818e
+  metadata.gz: 130796e31968cc4d325f42092eb82f8e21a67c56fdfc751116f354f6998c93f5
+  data.tar.gz: e4ec35da042e41699b25e607f642d9208564bf49f88f99be191029756f1e7f96
 SHA512:
-  metadata.gz: e4cec830738a0de711477620603757c2fade101075d64a9cbf824ecef806a994c7e0da655add3f495e2ac828a15a3e2b7db0143e32718a6aebbfa3fa3911fc70
-  data.tar.gz: e3a6d02dd6ce60e17e0ecdf5a255d0fe9886fc7533e0ad8c7334c0f3d0c03970c0aa4b01bdd90fa8342c3cb4225816b3a3658908e2e23e2ccfae2aa8fd1fc286
+  metadata.gz: 6cdeaf577ff2b53836dca41616b8c90fb0bdce77d0e8e8d456fcb1fc3889ae02373b72cf70df4829c77d22f3ef0217f211c02a39b779d3a06fdfd2aaba66c085
+  data.tar.gz: b1abf3df297599475a5876aef7fed5a4e6c304f5175ed686c003ee75214c08f87755a5c5fa7825a8171d37af495723e0d357c8e56511ca358190f998f4498dad

data/lib/db_validator/cli.rb

@@ -100,7 +100,7 @@ module DbValidator
 
       if available_models.empty?
         Rails.logger.debug "No models found in the application."
-        exit 1
+        raise "No models found in the application. Please run this command from your Rails application root."
       end
 
       selected_models = select_models(available_models)
@@ -116,7 +116,7 @@ module DbValidator
       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
+      raise "Rails application not found. Please run this command from your Rails application root."
     end
 
     def configure_validator(models = nil, options = {})

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/formatters/json_formatter.rb

@@ -33,7 +33,7 @@ module DbValidator
 
       def save_to_file(data)
         FileUtils.mkdir_p("db_validator_reports")
-        timestamp = Time.now.strftime("%Y%m%d_%H%M%S")
+        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))

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

@@ -3,6 +3,7 @@
 require "tty-box"
 require "tty-spinner"
 require "db_validator/formatters/json_formatter"
+require "db_validator/formatters/message_formatter"
 
 module DbValidator
   class Reporter
@@ -11,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 << {
@@ -29,6 +26,11 @@ 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
@@ -40,22 +42,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
+    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,
@@ -71,50 +132,9 @@ module DbValidator
         "Database Validation Report"
       end
 
-      report.puts title_box
-      report.puts
-
-      if @invalid_records.empty?
-        report.puts "No invalid records found."
-      else
-        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.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])
-
-            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}"
-            end
-            report.puts
-          end
-
-          report.puts
-        end
-      end
-
-      report.string
+      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

@@ -12,7 +12,7 @@ module DbValidator
     end
 
     def validate_all
-      models = get_models_to_validate
+      models = models_to_validate
       invalid_count = 0
 
       models.each do |model|
@@ -24,15 +24,21 @@ module DbValidator
         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
+        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?
+
+      "#{first_part} #{second_part}"
+    end
+
     def validate_test_model(model_name)
       model = model_name.constantize
       scope = model.all
@@ -97,25 +103,31 @@ module DbValidator
     end
 
     def validate_model(model)
-      config = DbValidator.configuration
-      batch_size = config.batch_size || 100
-      limit = config.limit
-
-      scope = model.all
-      scope = scope.limit(limit) if limit
-
+      scope = build_scope(model)
       total_count = scope.count
       return 0 if total_count.zero?
 
+      process_records(scope, model, total_count)
+    end
+
+    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|
-            invalid_count += 1 unless 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}" }
@@ -124,6 +136,15 @@ module DbValidator
       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)
       ProgressBar.create(
         title: "Validating #{model_name}",
@@ -140,7 +161,7 @@ module DbValidator
       false
     end
 
-    def get_models_to_validate
+    def models_to_validate
       models = find_all_models
       models.select { |model| should_validate_model?(model) }
     end

data/lib/db_validator/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module DbValidator
-  VERSION = "0.3.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/tasks/db_validator_tasks.rake

@@ -3,93 +3,23 @@
 namespace :db_validator do
   desc "Validate records in the database"
   task validate: :environment do
-    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
-
-      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
-      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}"
+    DbValidator::ValidateTask.new.execute
   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
+      raise "No models found in the application. Please run this command from your Rails application root."
     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
+    DbValidator::TestTask.new(model_name, validation_rule).execute
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: db_validator
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 1.0.0
 platform: ruby
 authors:
 - Krzysztof Duda
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-11-09 00:00:00.000000000 Z
+date: 2024-12-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -136,10 +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