rails_console_pro 0.1.0

data/lib/rails_console_pro/model_validator.rb

@@ -0,0 +1,219 @@
+# frozen_string_literal: true
+
+module RailsConsolePro
+  # Utility module for validating ActiveRecord models and handling edge cases
+  module ModelValidator
+    extend self
+
+    # Check if model is a valid ActiveRecord model
+    def valid_model?(model_class)
+      return false unless model_class.is_a?(Class)
+      return false unless model_class < ActiveRecord::Base
+      true
+    end
+
+    # Check if model has a database table
+    def has_table?(model_class)
+      return false unless valid_model?(model_class)
+      return false if abstract_class?(model_class)
+      
+      # Use ActiveRecord's table_exists? method
+      model_class.table_exists?
+    rescue => e
+      # If table_exists? fails, assume no table
+      false
+    end
+
+    # Check if model is abstract
+    def abstract_class?(model_class)
+      return false unless valid_model?(model_class)
+      model_class.abstract_class?
+    end
+
+    # Check if model uses Single Table Inheritance (STI)
+    def sti_model?(model_class)
+      return false unless valid_model?(model_class)
+      return false unless has_table?(model_class)
+      
+      # Check if model has a type column (STI indicator)
+      model_class.column_names.include?(model_class.inheritance_column)
+    end
+
+    # Check if model has created_at column (for growth rate calculations)
+    def has_timestamp_column?(model_class, column_name = 'created_at')
+      return false unless valid_model?(model_class)
+      return false unless has_table?(model_class)
+      
+      model_class.column_names.include?(column_name.to_s)
+    end
+
+    # Check if table is very large (for performance considerations)
+    def large_table?(model_class, threshold: nil)
+      return false unless valid_model?(model_class)
+      return false unless has_table?(model_class)
+      
+      threshold ||= RailsConsolePro.config.stats_large_table_threshold
+      
+      begin
+        count = model_class.count
+        count > threshold
+      rescue => e
+        # If count fails, assume not large (safer)
+        false
+      end
+    end
+
+    # Get model type information
+    def model_info(model_class)
+      {
+        valid: valid_model?(model_class),
+        has_table: has_table?(model_class),
+        abstract: abstract_class?(model_class),
+        sti: sti_model?(model_class),
+        has_created_at: has_timestamp_column?(model_class),
+        large: large_table?(model_class)
+      }
+    end
+
+    # Validate model and return error message if invalid
+    def validate_for_schema(model_class)
+      return "Not an ActiveRecord model" unless valid_model?(model_class)
+      return "Abstract class - no database table" if abstract_class?(model_class)
+      return "Model has no database table" unless has_table?(model_class)
+      
+      nil # Valid
+    end
+
+    # Validate model and return error message if invalid for stats
+    def validate_for_stats(model_class)
+      schema_error = validate_for_schema(model_class)
+      return schema_error if schema_error
+      
+      nil # Valid
+    end
+
+    # Check if associations are valid (not empty or broken)
+    def valid_associations?(model_class, association_name)
+      return false unless valid_model?(model_class)
+      
+      begin
+        association = model_class.reflect_on_association(association_name)
+        return false unless association
+        
+        # Check if associated class exists
+        associated_class = association.klass
+        return false unless associated_class < ActiveRecord::Base
+        
+        true
+      rescue => e
+        false
+      end
+    end
+
+    # Safely get table name
+    def safe_table_name(model_class)
+      return nil unless valid_model?(model_class)
+      
+      begin
+        model_class.table_name
+      rescue => e
+        nil
+      end
+    end
+
+    # Safely get column names
+    def safe_column_names(model_class)
+      return [] unless valid_model?(model_class)
+      return [] unless has_table?(model_class)
+      
+      begin
+        model_class.column_names
+      rescue => e
+        []
+      end
+    end
+
+    # Safely get columns
+    def safe_columns(model_class)
+      return [] unless valid_model?(model_class)
+      return [] unless has_table?(model_class)
+      
+      begin
+        model_class.columns
+      rescue => e
+        []
+      end
+    end
+
+    # Safely get indexes
+    def safe_indexes(model_class)
+      return [] unless valid_model?(model_class)
+      return [] unless has_table?(model_class)
+      
+      begin
+        table_name = safe_table_name(model_class)
+        return [] unless table_name
+        
+        model_class.connection.indexes(table_name)
+      rescue => e
+        []
+      end
+    end
+
+    # Safely get associations
+    def safe_associations(model_class, macro = nil)
+      return [] unless valid_model?(model_class)
+      
+      begin
+        if macro
+          model_class.reflect_on_all_associations(macro)
+        else
+          model_class.reflect_on_all_associations
+        end
+      rescue => e
+        []
+      end
+    end
+
+    # Check if model has unusual inheritance patterns
+    def unusual_inheritance?(model_class)
+      return false unless valid_model?(model_class)
+      
+      # Check for non-standard inheritance patterns
+      # This is a heuristic - models that inherit from non-standard base classes
+      base_class = model_class.superclass
+      
+      # If superclass is not ActiveRecord::Base and not abstract, it's unusual
+      if base_class != ActiveRecord::Base && !base_class.abstract_class?
+        # Check if it's a legitimate ActiveRecord model
+        return true unless base_class < ActiveRecord::Base
+      end
+      
+      false
+    rescue => e
+      # If we can't determine, assume it's fine
+      false
+    end
+
+    # Validate model and raise error if invalid (for use in initializers)
+    def validate_model!(model_class)
+      unless valid_model?(model_class)
+        raise ArgumentError, "#{model_class} is not an ActiveRecord model"
+      end
+      model_class
+    end
+
+    # Validate model for schema inspection and raise error if invalid
+    def validate_model_for_schema!(model_class)
+      validate_model!(model_class)
+      if abstract_class?(model_class)
+        raise ArgumentError, "#{model_class} is an abstract class and has no database table"
+      end
+      unless has_table?(model_class)
+        raise ArgumentError, "#{model_class} has no database table"
+      end
+      model_class
+    end
+  end
+end
+

data/lib/rails_console_pro/paginator.rb

@@ -0,0 +1,204 @@
+# frozen_string_literal: true
+
+module RailsConsolePro
+  # Smart paginator for large collections with lazy enumeration
+  # Uses advanced Ruby concepts: Enumerator, lazy evaluation, and interactive I/O
+  class Paginator
+    include ColorHelper
+
+    # Navigation commands
+    COMMANDS = {
+      next: ['n', 'next', ''],
+      previous: ['p', 'prev', 'previous'],
+      first: ['f', 'first'],
+      last: ['l', 'last'],
+      jump: ['j', 'jump', 'goto', 'g'],
+      quit: ['q', 'quit', 'exit']
+    }.freeze
+
+    def initialize(output, collection, total_count, config, record_printer_proc)
+      @output = output
+      @collection = collection
+      @total_count = total_count
+      @config = config
+      @record_printer_proc = record_printer_proc
+      @page_size = config.pagination_page_size
+      @current_page = 1
+      @total_pages = calculate_total_pages
+    end
+
+    # Start paginated display
+    def paginate
+      return print_all if @total_count <= @config.pagination_threshold || !@config.pagination_enabled
+
+      loop do
+        print_page
+        command = get_user_command
+        break if command == :quit
+
+        handle_command(command)
+      end
+    end
+
+    private
+
+    def calculate_total_pages
+      (@total_count.to_f / @page_size).ceil
+    end
+
+    def print_all
+      # For small collections, print everything without pagination
+      @collection.each_with_index do |record, index|
+        print_record(record, index)
+      end
+    end
+
+    def print_page
+      clear_screen_info
+      print_header
+      
+      records = page_records
+      records.each_with_index do |record, index|
+        global_index = page_start_index + index
+        print_record(record, global_index)
+      end
+      
+      print_footer
+      print_pagination_controls
+    end
+
+    def page_records
+      # Use lazy enumeration to avoid loading unnecessary records
+      start_index = page_start_index
+      
+      if @collection.is_a?(ActiveRecord::Relation)
+        # For Relations, use offset/limit for efficient database queries
+        @collection.offset(start_index).limit(@page_size).to_a
+      elsif @collection.respond_to?(:to_ary)
+        # For arrays, use slice for better performance (O(1) with range)
+        @collection[start_index, @page_size] || []
+      elsif @collection.respond_to?(:each)
+        # For other enumerables, use lazy enumeration
+        @collection.lazy.drop(start_index).take(@page_size).to_a
+      else
+        []
+      end
+    end
+
+    def page_start_index
+      (@current_page - 1) * @page_size
+    end
+
+    def page_end_index
+      [page_start_index + @page_size - 1, @total_count - 1].min
+    end
+
+    def print_record(record, index)
+      @output.puts color(@config.get_color(:info), "[#{index}]")
+      @record_printer_proc.call(record)
+    end
+
+    def print_header
+      model_name = extract_model_name
+      showing = "#{page_start_index + 1}-#{page_end_index + 1}"
+      header = "#{model_name} Collection (Showing #{showing} of #{@total_count} records)"
+      @output.puts color(@config.get_color(:success), header)
+      @output.puts
+    end
+
+    def print_footer
+      @output.puts
+    end
+
+    def print_pagination_controls
+      page_info = color(@config.get_color(:info), "Page #{@current_page}/#{@total_pages}")
+      controls = "Commands: " + 
+                color(:dim, "[n]ext") + " " +
+                color(:dim, "[p]rev") + " " +
+                color(:dim, "[f]irst") + " " +
+                color(:dim, "[l]ast") + " " +
+                color(:dim, "[j]ump") + " " +
+                color(:dim, "[#]page") + " " +
+                color(:dim, "[q]uit")
+      
+      @output.puts page_info
+      @output.puts controls
+      @output.puts
+    end
+
+    def extract_model_name
+      if @collection.is_a?(ActiveRecord::Relation)
+        @collection.klass.name
+      elsif @collection.respond_to?(:to_ary) && !@collection.empty?
+        # For arrays, safely check first element
+        first_item = @collection[0]
+        first_item.is_a?(ActiveRecord::Base) ? first_item.class.name : "Collection"
+      else
+        "Collection"
+      end
+    end
+
+    def clear_screen_info
+      # Clear previous pagination info (simple approach - just add spacing)
+      @output.puts
+    end
+
+    def get_user_command
+      @output.print color(@config.get_color(:success), "➤ Enter command: ")
+      input = $stdin.gets&.chomp&.downcase&.strip || 'q'
+      
+      normalize_command(input)
+    end
+
+    def normalize_command(input)
+      COMMANDS.each do |command, aliases|
+        return command if aliases.include?(input)
+      end
+      
+      # Check if it's a page number (direct jump)
+      if input.match?(/^\d+$/)
+        page_num = input.to_i
+        if page_num.between?(1, @total_pages)
+          @current_page = page_num
+          return :page_changed
+        else
+          @output.puts color(@config.get_color(:error), "Invalid page number (1-#{@total_pages}). Staying on page #{@current_page}.")
+          return :noop
+        end
+      end
+      
+      # Default to next if unrecognized
+      :next
+    end
+
+    def handle_command(command)
+      case command
+      when :next
+        @current_page = [@current_page + 1, @total_pages].min
+      when :previous
+        @current_page = [@current_page - 1, 1].max
+      when :first
+        @current_page = 1
+      when :last
+        @current_page = @total_pages
+      when :jump
+        jump_to_page
+      when :page_changed, :noop
+        # Already handled in normalize_command
+      end
+    end
+
+    def jump_to_page
+      @output.print color(@config.get_color(:success), "➤ Enter page number (1-#{@total_pages}): ")
+      input = $stdin.gets&.chomp&.strip
+      page_num = input.to_i
+      
+      if page_num.between?(1, @total_pages)
+        @current_page = page_num
+      else
+        @output.puts color(@config.get_color(:error), "Invalid page number. Staying on page #{@current_page}.")
+      end
+    end
+  end
+end
+

data/lib/rails_console_pro/printers/active_record_printer.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module RailsConsolePro
+  module Printers
+    # Printer for ActiveRecord::Base instances
+    class ActiveRecordPrinter < BasePrinter
+      def print
+        class_name = value.class.name
+        id = value.id || "new"
+        header("#{class_name} ##{id}", 50)
+        
+        # Use each_pair for better performance than each
+        value.attributes.each_pair do |key, val|
+          print_attribute(key, val)
+        end
+        
+        footer(50)
+      end
+
+      private
+
+      def print_attribute(key, val)
+        key_color = config.get_color(:attribute_key)
+        key_str = bold_color(key_color, key.to_s)
+        val_str = format_value(val)
+        output.puts "│ #{key_str}: #{val_str}"
+      end
+    end
+  end
+end

data/lib/rails_console_pro/printers/collection_printer.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module RailsConsolePro
+  module Printers
+    # Printer for Array of ActiveRecord objects
+    class CollectionPrinter < BasePrinter
+      def print
+        return print_empty_collection if value.empty?
+        return print_non_active_record_array unless active_record_array?
+
+        # Use pagination for large collections
+        total_count = value.size
+        record_printer = proc { |record| ActiveRecordPrinter.new(output, record, pry_instance).print }
+        
+        Paginator.new(output, value, total_count, config, record_printer).paginate
+      end
+
+      private
+
+      def active_record_array?
+        !value.empty? && value.first.is_a?(ActiveRecord::Base)
+      end
+
+      def print_empty_collection
+        output.puts color(config.get_color(:warning), "Empty collection")
+      end
+
+      def print_non_active_record_array
+        # Fall back to default printer for non-AR arrays
+        BasePrinter.new(output, value, pry_instance).print
+      end
+    end
+  end
+end

data/lib/rails_console_pro/printers/diff_printer.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module RailsConsolePro
+  module Printers
+    # Printer for object comparison results
+    class DiffPrinter < BasePrinter
+      def print
+        print_header
+        print_type_comparison
+        print_identical_status
+        print_differences
+        print_footer
+      end
+
+      private
+
+      def print_header
+        header_color = config.get_color(:header)
+        output.puts bold_color(header_color, "═" * config.header_width)
+        output.puts bold_color(header_color, "🔍 OBJECT COMPARISON")
+        output.puts bold_color(header_color, "═" * config.header_width)
+      end
+
+      def print_type_comparison
+        return unless value.different_types?
+
+        output.puts bold_color(config.get_color(:warning), "\n⚠️  Type Mismatch:")
+        output.puts "  Object 1: #{color(config.get_color(:attribute_value_string), value.object1_type)}"
+        output.puts "  Object 2: #{color(config.get_color(:attribute_value_string), value.object2_type)}"
+      end
+
+      def print_identical_status
+        if value.identical
+          output.puts bold_color(config.get_color(:success), "\n✅ Objects are identical")
+        else
+          output.puts bold_color(config.get_color(:warning), "\n⚠️  Objects differ (#{value.diff_count} #{pluralize(value.diff_count, 'difference')})")
+        end
+      end
+
+      def print_differences
+        return if value.identical || !value.has_differences?
+
+        output.puts bold_color(config.get_color(:warning), "\n📊 Differences:")
+        
+        value.differences.each do |attribute, diff_data|
+          print_attribute_diff(attribute, diff_data)
+        end
+      end
+
+      def print_attribute_diff(attribute, diff_data)
+        key_color = config.get_color(:attribute_key)
+        output.puts "\n  #{bold_color(key_color, attribute.to_s)}:"
+        
+        case diff_data
+        when Hash
+          if diff_data[:old_value] && diff_data[:new_value]
+            # Show old → new
+            output.puts "    #{color(:dim, 'Old:')} #{format_value(diff_data[:old_value])}"
+            output.puts "    #{color(:dim, 'New:')} #{format_value(diff_data[:new_value])}"
+            
+            # Show change indicator
+            change_type = determine_change_type(diff_data[:old_value], diff_data[:new_value])
+            change_icon = change_type == :added ? "➕" : change_type == :removed ? "➖" : "🔄"
+            change_color = change_type == :added ? config.get_color(:success) : 
+                          change_type == :removed ? config.get_color(:error) : config.get_color(:warning)
+            output.puts "    #{color(change_color, "#{change_icon} Changed")}"
+          elsif diff_data[:only_in_object1]
+            output.puts "    #{color(config.get_color(:error), "Only in Object 1:")} #{format_value(diff_data[:only_in_object1])}"
+          elsif diff_data[:only_in_object2]
+            output.puts "    #{color(config.get_color(:success), "Only in Object 2:")} #{format_value(diff_data[:only_in_object2])}"
+          end
+        else
+          # Simple value comparison
+          output.puts "    #{color(config.get_color(:error), 'Object 1:')} #{format_value(value.object1)}"
+          output.puts "    #{color(config.get_color(:success), 'Object 2:')} #{format_value(value.object2)}"
+        end
+      end
+
+      def determine_change_type(old_value, new_value)
+        return :modified unless old_value.nil? || new_value.nil?
+        return :added if old_value.nil?
+        return :removed if new_value.nil?
+        :modified
+      end
+
+      def print_footer
+        footer_color = config.get_color(:footer)
+        output.puts bold_color(footer_color, "\n" + "═" * config.header_width)
+        output.puts color(:dim, "Generated: #{value.timestamp.strftime('%Y-%m-%d %H:%M:%S')}")
+      end
+
+      def pluralize(count, word)
+        count == 1 ? word : "#{word}s"
+      end
+    end
+  end
+end