rails_console_pro 0.1.0

data/lib/rails_console_pro/commands/explain_command.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+module RailsConsolePro
+  module Commands
+    class ExplainCommand < BaseCommand
+      def execute(relation_or_model, *args)
+        relation = build_relation(relation_or_model, *args)
+        return nil unless relation
+
+        execute_explain(relation)
+      rescue => e
+        RailsConsolePro::ErrorHandler.handle(e, context: :explain)
+      end
+
+      private
+
+      def build_relation(relation_or_model, *args)
+        if ModelValidator.valid_model?(relation_or_model)
+          args.empty? ? relation_or_model.all : relation_or_model.where(*args)
+        elsif relation_or_model.respond_to?(:to_sql)
+          relation_or_model
+        else
+          puts pastel.red("Error: Cannot explain #{relation_or_model.class}")
+          nil
+        end
+      end
+
+      def execute_explain(relation)
+        sql = relation.to_sql
+        start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC, :millisecond)
+        
+        explain_output = fetch_explain_output(sql)
+        relation.load
+        execution_time = Process.clock_gettime(Process::CLOCK_MONOTONIC, :millisecond) - start_time
+        
+        indexes_used, recommendations = analyze_explain_output(explain_output, sql, execution_time)
+        statistics = build_statistics(relation)
+        
+        ExplainResult.new(
+          sql: sql,
+          explain_output: explain_output,
+          execution_time: execution_time,
+          indexes_used: indexes_used,
+          recommendations: recommendations,
+          statistics: statistics
+        )
+      end
+
+      def fetch_explain_output(sql)
+        connection = ActiveRecord::Base.connection
+        adapter_name = connection.adapter_name.downcase
+        
+        if adapter_name.include?('postgresql')
+          explain_sql = "EXPLAIN (ANALYZE, BUFFERS, VERBOSE) #{sql}"
+          raw_explain = connection.execute(explain_sql)
+          raw_explain.values.flatten.join("\n")
+        elsif adapter_name.include?('mysql')
+          explain_sql = "EXPLAIN #{sql}"
+          connection.execute(explain_sql).to_a
+        else
+          connection.exec_query("EXPLAIN #{sql}").to_a
+        end
+      end
+
+      def analyze_explain_output(explain_output, sql, execution_time)
+        indexes_used = []
+        recommendations = []
+        
+        case explain_output
+        when String
+          analyze_postgresql_output(explain_output, recommendations, indexes_used)
+        when Array
+          analyze_mysql_output(explain_output, recommendations, indexes_used)
+        end
+        
+        add_performance_recommendations(sql, execution_time, recommendations)
+        [indexes_used, recommendations]
+      end
+
+      def analyze_postgresql_output(explain_output, recommendations, indexes_used)
+        recommendations << "Sequential scan detected - consider adding an index" if explain_output.include?("Seq Scan")
+        
+        explain_output.scan(/Index (?:Scan|Only Scan) using (\w+)/) do |match|
+          indexes_used << match[0]
+        end
+      end
+
+      def analyze_mysql_output(explain_output, recommendations, indexes_used)
+        explain_output.each do |row|
+          next unless row.is_a?(Hash)
+          
+          key = row['key'] || row[:key]
+          indexes_used << key if key
+          
+          type = (row['type'] || row[:type]).to_s.downcase
+          if type == 'all'
+            table = row['table'] || row[:table]
+            recommendations << "Full table scan on #{table} - consider adding an index"
+          end
+        end
+      end
+
+      def add_performance_recommendations(sql, execution_time, recommendations)
+        recommendations << "Query took over 100ms - consider optimization" if execution_time > 100
+        recommendations << "LIKE query detected - ensure you're not using leading wildcards (%value)" if sql.downcase.include?('like')
+      end
+
+      def build_statistics(relation)
+        {
+          "Total Rows" => relation.count,
+          "Tables Involved" => relation.klass.table_name,
+          "Database Adapter" => ActiveRecord::Base.connection.adapter_name.capitalize
+        }
+      end
+    end
+  end
+end
+

data/lib/rails_console_pro/commands/export_command.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module RailsConsolePro
+  module Commands
+    class ExportCommand < BaseCommand
+      def execute(data, file_path, format: nil)
+        return nil if data.nil?
+        
+        FormatExporter.export_to_file(data, file_path, format: format)
+      rescue => e
+        RailsConsolePro::ErrorHandler.handle(e, context: :export)
+      end
+    end
+  end
+end
+

data/lib/rails_console_pro/commands/schema_command.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module RailsConsolePro
+  module Commands
+    class SchemaCommand < BaseCommand
+      def execute(model_class)
+        error_message = ModelValidator.validate_for_schema(model_class)
+        if error_message
+          puts pastel.red("Error: #{error_message}")
+          return nil
+        end
+
+        SchemaInspectorResult.new(model_class)
+      rescue => e
+        RailsConsolePro::ErrorHandler.handle(e, context: :schema)
+      end
+    end
+  end
+end
+

data/lib/rails_console_pro/commands/stats_command.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module RailsConsolePro
+  module Commands
+    class StatsCommand < BaseCommand
+      def execute(model_class)
+        return nil if model_class.nil?
+        
+        error_message = ModelValidator.validate_for_stats(model_class)
+        if error_message
+          puts pastel.red("Error: #{error_message}")
+          return nil
+        end
+
+        execute_stats(model_class)
+      rescue => e
+        RailsConsolePro::ErrorHandler.handle(e, context: :stats)
+      end
+
+      private
+
+      def execute_stats(model_class)
+        connection = model_class.connection
+        # Get table name directly since model is already validated
+        table_name = begin
+          model_class.table_name
+        rescue => e
+          # If we can't get table name, we can't calculate all stats
+          puts pastel.yellow("Warning: Could not get table name for #{model_class.name}: #{e.message}")
+          return nil
+        end
+
+        # Double-check table exists (defensive check)
+        unless ModelValidator.has_table?(model_class)
+          puts pastel.yellow("Warning: Table does not exist for #{model_class.name}")
+          return nil
+        end
+
+        # Record count (safe with error handling)
+        record_count = safe_count(model_class)
+        safe_count_proc = -> { safe_count(model_class) }
+
+        # Growth rate (only if created_at exists)
+        growth_rate = if ModelValidator.has_timestamp_column?(model_class)
+                        Services::StatsCalculator.calculate_growth_rate(model_class, safe_count_proc)
+                      else
+                        nil
+                      end
+
+        # Table size (database-specific)
+        table_size = Services::TableSizeCalculator.calculate(connection, table_name)
+
+        # Index usage (safe with error handling)
+        index_usage = Services::IndexAnalyzer.analyze(connection, table_name)
+
+        # Column statistics (only for smaller tables)
+        column_stats = if ModelValidator.large_table?(model_class)
+                         {} # Skip for large tables to avoid performance issues
+                       else
+                         Services::ColumnStatsCalculator.calculate(
+                           model_class,
+                           connection,
+                           table_name,
+                           safe_count_proc,
+                           config
+                         )
+                       end
+
+        StatsResult.new(
+          model: model_class,
+          record_count: record_count,
+          growth_rate: growth_rate,
+          table_size: table_size,
+          index_usage: index_usage,
+          column_stats: column_stats
+        )
+      end
+
+      def safe_count(model_class)
+        model_class.count
+      rescue ActiveRecord::StatementInvalid => e
+        raise e # Re-raise StatementInvalid so it can be caught by stats method
+      rescue => e
+        0 # Return 0 for other errors
+      end
+
+      def config
+        RailsConsolePro.config
+      end
+    end
+  end
+end
+

data/lib/rails_console_pro/commands.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module RailsConsolePro
+  # Command methods for schema inspection and SQL explain
+  # Thin facade that delegates to command classes
+  module Commands
+    extend self
+
+    # Schema inspection command
+    def schema(model_class)
+      SchemaCommand.new.execute(model_class)
+    end
+
+    # SQL explain command
+    def explain(relation_or_model, *args)
+      ExplainCommand.new.execute(relation_or_model, *args)
+    end
+
+    # Export data to file (works with any exportable object)
+    def export(data, file_path, format: nil)
+      ExportCommand.new.execute(data, file_path, format: format)
+    end
+
+    # Model statistics command
+    def stats(model_class)
+      StatsCommand.new.execute(model_class)
+    end
+
+    # Object comparison command
+    def diff(object1, object2)
+      DiffCommand.new.execute(object1, object2)
+    end
+  end
+end

data/lib/rails_console_pro/configuration.rb

@@ -0,0 +1,219 @@
+# frozen_string_literal: true
+
+module RailsConsolePro
+  # Configuration class for Enhanced Console Printer
+  class Configuration
+    # Color scheme presets
+    COLOR_SCHEMES = {
+      dark: {
+        header: :bright_blue,
+        footer: :bright_blue,
+        border: :dim,
+        attribute_key: :blue,
+        attribute_value_nil: :white,
+        attribute_value_numeric: :bright_blue,
+        attribute_value_boolean: :green,
+        attribute_value_time: :blue,
+        attribute_value_string: :white,
+        error: :red,
+        success: :green,
+        warning: :yellow,
+        info: :cyan
+      },
+      light: {
+        header: :bright_cyan,
+        footer: :bright_cyan,
+        border: :dim,
+        attribute_key: :bright_blue,
+        attribute_value_nil: :black,
+        attribute_value_numeric: :blue,
+        attribute_value_boolean: :green,
+        attribute_value_time: :cyan,
+        attribute_value_string: :black,
+        error: :red,
+        success: :green,
+        warning: :yellow,
+        info: :cyan
+      },
+      custom: {} # Will be populated by user
+    }.freeze
+
+    # Feature toggles
+    attr_accessor :enabled
+    attr_accessor :schema_command_enabled
+    attr_accessor :explain_command_enabled
+    attr_accessor :navigate_command_enabled
+    attr_accessor :stats_command_enabled
+    attr_accessor :diff_command_enabled
+    attr_accessor :active_record_printer_enabled
+    attr_accessor :relation_printer_enabled
+    attr_accessor :collection_printer_enabled
+    attr_accessor :export_enabled
+
+    # Color customization
+    attr_accessor :color_scheme
+    attr_accessor :colors
+
+    # Style customization
+    attr_accessor :max_depth
+    attr_accessor :show_sql_by_default
+    attr_accessor :show_welcome_message
+    attr_accessor :border_char
+    attr_accessor :header_width
+
+    # Type-specific colors (for schema printer)
+    attr_accessor :type_colors
+
+    # Validator colors (for schema printer)
+    attr_accessor :validator_colors
+
+    # Pagination settings
+    attr_accessor :pagination_enabled
+    attr_accessor :pagination_threshold
+    attr_accessor :pagination_page_size
+
+    # Stats calculation settings
+    attr_accessor :stats_large_table_threshold
+    attr_accessor :stats_skip_distinct_threshold
+
+    def initialize
+      # Default feature toggles - all enabled
+      @enabled = true
+      @schema_command_enabled = true
+      @explain_command_enabled = true
+      @navigate_command_enabled = true
+      @stats_command_enabled = true
+      @diff_command_enabled = true
+      @active_record_printer_enabled = true
+      @relation_printer_enabled = true
+      @collection_printer_enabled = true
+      @export_enabled = true
+
+      # Default color scheme
+      @color_scheme = :dark
+      @colors = COLOR_SCHEMES[:dark].dup
+
+      # Default style options
+      @max_depth = 10
+      @show_sql_by_default = false
+      @show_welcome_message = true
+      @border_char = "─"
+      @header_width = 60
+
+      # Default type colors
+      @type_colors = {
+        integer: :bright_blue,
+        bigint: :bright_blue,
+        decimal: :bright_blue,
+        float: :bright_blue,
+        string: :green,
+        text: :green,
+        datetime: :cyan,
+        timestamp: :cyan,
+        date: :cyan,
+        time: :cyan,
+        boolean: :magenta,
+        json: :yellow,
+        jsonb: :yellow
+      }
+
+      # Default validator colors
+      @validator_colors = {
+        'PresenceValidator' => :red,
+        'UniquenessValidator' => :magenta,
+        'LengthValidator' => :cyan,
+        'FormatValidator' => :yellow,
+        'NumericalityValidator' => :blue,
+        'InclusionValidator' => :green,
+        'ExclusionValidator' => :red,
+        'ConfirmationValidator' => :cyan,
+        'AcceptanceValidator' => :green
+      }
+
+      # Default pagination settings
+      @pagination_enabled = true
+      @pagination_threshold = 10  # Automatically paginate collections with 10+ items
+      @pagination_page_size = 5   # Show 5 records per page
+
+      # Default stats calculation settings
+      @stats_large_table_threshold = 10_000  # Consider table large if it has 10k+ records
+      @stats_skip_distinct_threshold = 10_000  # Skip distinct count for tables with 10k+ records
+    end
+
+    # Set color scheme (dark, light, or custom)
+    def color_scheme=(scheme)
+      @color_scheme = scheme.to_sym
+      if COLOR_SCHEMES.key?(@color_scheme) && @color_scheme != :custom
+        @colors = COLOR_SCHEMES[@color_scheme].dup
+      end
+    end
+
+    # Set a custom color
+    def set_color(key, value)
+      @colors = @colors.dup unless @colors.frozen?
+      @colors[key.to_sym] = value.to_sym
+      @color_scheme = :custom
+    end
+
+    # Get a color value
+    def get_color(key)
+      @colors[key.to_sym] || :white
+    end
+
+    # Set type color
+    def set_type_color(type, color)
+      @type_colors = @type_colors.dup if @type_colors.frozen?
+      @type_colors[type.to_sym] = color.to_sym
+    end
+
+    # Get type color
+    def get_type_color(type)
+      @type_colors[type.to_sym] || :white
+    end
+
+    # Set validator color
+    def set_validator_color(validator_type, color)
+      @validator_colors = @validator_colors.dup if @validator_colors.frozen?
+      @validator_colors[validator_type.to_s] = color.to_sym
+    end
+
+    # Get validator color
+    def get_validator_color(validator_type)
+      @validator_colors[validator_type.to_s] || :white
+    end
+
+    # Disable all features
+    def disable_all
+      @enabled = false
+      @schema_command_enabled = false
+      @explain_command_enabled = false
+      @navigate_command_enabled = false
+      @stats_command_enabled = false
+      @diff_command_enabled = false
+      @active_record_printer_enabled = false
+      @relation_printer_enabled = false
+      @collection_printer_enabled = false
+      @export_enabled = false
+    end
+
+    # Enable all features
+    def enable_all
+      @enabled = true
+      @schema_command_enabled = true
+      @explain_command_enabled = true
+      @navigate_command_enabled = true
+      @stats_command_enabled = true
+      @diff_command_enabled = true
+      @active_record_printer_enabled = true
+      @relation_printer_enabled = true
+      @collection_printer_enabled = true
+      @export_enabled = true
+    end
+
+    # Reset to defaults
+    def reset
+      initialize
+    end
+  end
+end
+

data/lib/rails_console_pro/diff_result.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module RailsConsolePro
+  # Value object for object comparison results
+  class DiffResult
+    attr_reader :object1, :object2, :differences, :identical, :object1_type, 
+                :object2_type, :timestamp
+
+    def initialize(object1:, object2:, differences: {}, identical: false,
+                   object1_type: nil, object2_type: nil, timestamp: Time.current)
+      @object1 = object1
+      @object2 = object2
+      @differences = differences
+      @identical = identical
+      @object1_type = object1_type || object1.class.name
+      @object2_type = object2_type || object2.class.name
+      @timestamp = timestamp
+    end
+
+    def ==(other)
+      other.is_a?(self.class) && other.object1 == object1 && other.object2 == object2
+    end
+
+    def has_differences?
+      !identical && differences.any?
+    end
+
+    def different_types?
+      object1_type != object2_type
+    end
+
+    def diff_count
+      differences.size
+    end
+
+    # Export to JSON
+    def to_json(pretty: true)
+      FormatExporter.to_json(self, pretty: pretty)
+    end
+
+    # Export to YAML
+    def to_yaml
+      FormatExporter.to_yaml(self)
+    end
+
+    # Export to HTML
+    def to_html(style: :default)
+      FormatExporter.to_html(self, title: "Diff Comparison", style: style)
+    end
+
+    # Export to file
+    def export_to_file(file_path, format: nil)
+      FormatExporter.export_to_file(self, file_path, format: format)
+    end
+  end
+end

data/lib/rails_console_pro/error_handler.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module RailsConsolePro
+  # Unified error handler for consistent error handling across the gem
+  module ErrorHandler
+    extend self
+    include ColorHelper
+
+    def handle(error, context: nil)
+      case error
+      when ActiveRecord::ConfigurationError
+        handle_configuration_error(error, context)
+      when ActiveRecord::StatementInvalid
+        handle_sql_error(error, context)
+      when ArgumentError
+        handle_argument_error(error, context)
+      when NameError
+        handle_name_error(error, context)
+      else
+        handle_generic_error(error, context)
+      end
+    end
+
+    private
+
+    def handle_configuration_error(error, context)
+      puts pastel.red.bold("❌ Configuration Error: #{error.message}")
+      puts pastel.yellow("💡 Tip: Check that all associations exist in your models")
+      nil
+    end
+
+    def handle_sql_error(error, context)
+      puts pastel.red.bold("❌ SQL Error: #{error.message}")
+      puts pastel.yellow("💡 Tip: Check your query syntax and table/column names")
+      nil
+    end
+
+    def handle_argument_error(error, context)
+      puts pastel.red.bold("❌ Error: #{error.message}")
+      nil
+    end
+
+    def handle_name_error(error, context)
+      message = error.message.include?('uninitialized constant') ? 
+        "Could not find model or class" : error.message
+      puts pastel.red.bold("❌ Error: #{message}")
+      puts pastel.yellow("💡 Tip: Make sure the model name is correct and loaded")
+      nil
+    end
+
+    def handle_generic_error(error, context)
+      puts pastel.red.bold("❌ Error: #{error.message}")
+      if Rails.env.development? || ENV['RAILS_CONSOLE_PRO_DEBUG']
+        puts pastel.dim(error.backtrace.first(3).join("\n"))
+      end
+      nil
+    end
+  end
+end
+

data/lib/rails_console_pro/explain_result.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module RailsConsolePro
+  # Value object for SQL explain results
+  class ExplainResult
+    attr_reader :sql, :explain_output, :execution_time, :indexes_used, 
+                :recommendations, :statistics
+
+    def initialize(sql:, explain_output:, execution_time: nil, 
+                   indexes_used: [], recommendations: [], statistics: nil)
+      @sql = sql
+      @explain_output = explain_output
+      @execution_time = execution_time
+      @indexes_used = Array(indexes_used)
+      @recommendations = Array(recommendations)
+      @statistics = statistics || {}
+    end
+
+    def slow_query?
+      execution_time && execution_time > 100
+    end
+
+    def has_indexes?
+      indexes_used.any?
+    end
+
+    # Export to JSON
+    def to_json(pretty: true)
+      FormatExporter.to_json(self, pretty: pretty)
+    end
+
+    # Export to YAML
+    def to_yaml
+      FormatExporter.to_yaml(self)
+    end
+
+    # Export to HTML
+    def to_html(style: :default)
+      FormatExporter.to_html(self, title: "SQL Explain Analysis", style: style)
+    end
+
+    # Export to file
+    def export_to_file(file_path, format: nil)
+      FormatExporter.export_to_file(self, file_path, format: format)
+    end
+  end
+end