rails_console_pro 0.1.3 → 0.1.4

data/lib/rails_console_pro/commands/introspect_command.rb

@@ -0,0 +1,220 @@
+# frozen_string_literal: true
+
+module RailsConsolePro
+  module Commands
+    # Command for model introspection
+    class IntrospectCommand < BaseCommand
+      def execute(model_class, *options)
+        error_message = ModelValidator.validate_for_schema(model_class)
+        if error_message
+          puts pastel.red("Error: #{error_message}")
+          return nil
+        end
+
+        # Parse options
+        opts = parse_options(options)
+
+        # Collect introspection data
+        collector = Services::IntrospectionCollector.new(model_class)
+        data = collector.collect
+
+        # If specific option requested, handle it
+        if opts[:callbacks_only]
+          return handle_callbacks_only(model_class, data[:callbacks])
+        elsif opts[:enums_only]
+          return handle_enums_only(model_class, data[:enums])
+        elsif opts[:concerns_only]
+          return handle_concerns_only(model_class, data[:concerns])
+        elsif opts[:scopes_only]
+          return handle_scopes_only(model_class, data[:scopes])
+        elsif opts[:validations_only]
+          return handle_validations_only(model_class, data[:validations])
+        elsif opts[:method_source]
+          return handle_method_source(model_class, opts[:method_source])
+        end
+
+        # Return full result
+        IntrospectResult.new(
+          model: model_class,
+          callbacks: data[:callbacks],
+          enums: data[:enums],
+          concerns: data[:concerns],
+          scopes: data[:scopes],
+          validations: data[:validations],
+          lifecycle_hooks: data[:lifecycle_hooks]
+        )
+      rescue => e
+        RailsConsolePro::ErrorHandler.handle(e, context: :introspect)
+      end
+
+      private
+
+      def parse_options(options)
+        opts = {}
+        options.each do |opt|
+          case opt
+          when :callbacks, 'callbacks'
+            opts[:callbacks_only] = true
+          when :enums, 'enums'
+            opts[:enums_only] = true
+          when :concerns, 'concerns'
+            opts[:concerns_only] = true
+          when :scopes, 'scopes'
+            opts[:scopes_only] = true
+          when :validations, 'validations'
+            opts[:validations_only] = true
+          else
+            # Check if it's a method name for source lookup
+            if opt.is_a?(Symbol) || opt.is_a?(String)
+              opts[:method_source] = opt
+            end
+          end
+        end
+        opts
+      end
+
+      def handle_callbacks_only(model_class, callbacks)
+        if callbacks.empty?
+          puts pastel.yellow("No callbacks found for #{model_class.name}")
+          return nil
+        end
+
+        print_callbacks_summary(model_class, callbacks)
+        nil
+      end
+
+      def handle_enums_only(model_class, enums)
+        if enums.empty?
+          puts pastel.yellow("No enums found for #{model_class.name}")
+          return nil
+        end
+
+        print_enums_summary(model_class, enums)
+        nil
+      end
+
+      def handle_concerns_only(model_class, concerns)
+        if concerns.empty?
+          puts pastel.yellow("No concerns found for #{model_class.name}")
+          return nil
+        end
+
+        print_concerns_summary(model_class, concerns)
+        nil
+      end
+
+      def handle_scopes_only(model_class, scopes)
+        if scopes.empty?
+          puts pastel.yellow("No scopes found for #{model_class.name}")
+          return nil
+        end
+
+        print_scopes_summary(model_class, scopes)
+        nil
+      end
+
+      def handle_validations_only(model_class, validations)
+        if validations.empty?
+          puts pastel.yellow("No validations found for #{model_class.name}")
+          return nil
+        end
+
+        print_validations_summary(model_class, validations)
+        nil
+      end
+
+      def handle_method_source(model_class, method_name)
+        collector = Services::IntrospectionCollector.new(model_class)
+        location = collector.method_source_location(method_name)
+
+        if location.nil?
+          puts pastel.yellow("Method '#{method_name}' not found or source location unavailable")
+          return nil
+        end
+
+        print_method_source(method_name, location)
+        nil
+      end
+
+      # Quick print methods for specific data
+      def print_callbacks_summary(model_class, callbacks)
+        puts pastel.bold.bright_blue("Callbacks for #{model_class.name}:")
+        puts pastel.dim("─" * 60)
+        
+        callbacks.each do |type, chain|
+          puts "\n#{pastel.cyan(type.to_s)}:"
+          chain.each_with_index do |callback, index|
+            conditions = []
+            conditions << "if: #{callback[:if].join(', ')}" if callback[:if]
+            conditions << "unless: #{callback[:unless].join(', ')}" if callback[:unless]
+            
+            condition_str = conditions.any? ? " (#{conditions.join(', ')})" : ""
+            puts "  #{index + 1}. #{pastel.green(callback[:name])}#{condition_str}"
+          end
+        end
+      end
+
+      def print_enums_summary(model_class, enums)
+        puts pastel.bold.bright_blue("Enums for #{model_class.name}:")
+        puts pastel.dim("─" * 60)
+        
+        enums.each do |name, data|
+          puts "\n#{pastel.cyan(name)}:"
+          puts "  Type: #{pastel.yellow(data[:type])}"
+          puts "  Values: #{pastel.green(data[:values].join(', '))}"
+        end
+      end
+
+      def print_concerns_summary(model_class, concerns)
+        puts pastel.bold.bright_blue("Concerns for #{model_class.name}:")
+        puts pastel.dim("─" * 60)
+        
+        concerns.each do |concern|
+          type_badge = case concern[:type]
+                      when :concern then pastel.green('[Concern]')
+                      when :class then pastel.blue('[Class]')
+                      else pastel.yellow('[Module]')
+                      end
+          
+          puts "\n#{type_badge} #{pastel.cyan(concern[:name])}"
+          if concern[:location]
+            puts "  #{pastel.dim(concern[:location][:file])}:#{concern[:location][:line]}"
+          end
+        end
+      end
+
+      def print_scopes_summary(model_class, scopes)
+        puts pastel.bold.bright_blue("Scopes for #{model_class.name}:")
+        puts pastel.dim("─" * 60)
+        
+        scopes.each do |name, data|
+          puts "\n#{pastel.cyan(name)}:"
+          puts "  #{pastel.dim(data[:sql])}"
+        end
+      end
+
+      def print_validations_summary(model_class, validations)
+        puts pastel.bold.bright_blue("Validations for #{model_class.name}:")
+        puts pastel.dim("─" * 60)
+        
+        validations.each do |attribute, validators|
+          puts "\n#{pastel.cyan(attribute)}:"
+          validators.each do |validator|
+            opts_str = validator[:options].map { |k, v| "#{k}: #{v}" }.join(', ')
+            opts_str = " (#{opts_str})" unless opts_str.empty?
+            puts "  - #{pastel.green(validator[:type])}#{opts_str}"
+          end
+        end
+      end
+
+      def print_method_source(method_name, location)
+        puts pastel.bold.bright_blue("Method: #{method_name}")
+        puts pastel.dim("─" * 60)
+        puts "  Owner: #{pastel.cyan(location[:owner])}"
+        puts "  Type: #{pastel.yellow(location[:type])}"
+        puts "  Location: #{pastel.green(location[:file])}:#{location[:line]}"
+      end
+    end
+  end
+end
+

data/lib/rails_console_pro/commands/query_builder_command.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module RailsConsolePro
+  module Commands
+    # Command for interactive query building
+    class QueryBuilderCommand < BaseCommand
+      def execute(model_class, &block)
+        return disabled_message unless enabled?
+        return pastel.red("#{model_class} is not an ActiveRecord model") unless valid_model?(model_class)
+
+        builder = QueryBuilder.new(model_class)
+        
+        if block_given?
+          builder.instance_eval(&block)
+          builder.build
+        else
+          builder.build
+        end
+      rescue => e
+        RailsConsolePro::ErrorHandler.handle(e, context: :query_builder)
+      end
+
+      private
+
+      def enabled?
+        RailsConsolePro.config.enabled && RailsConsolePro.config.query_builder_command_enabled
+      end
+
+      def disabled_message
+        pastel.yellow('Query builder command is disabled. Enable it via RailsConsolePro.configure { |c| c.query_builder_command_enabled = true }')
+      end
+
+      def valid_model?(model_class)
+        ModelValidator.valid_model?(model_class)
+      end
+
+      def config
+        RailsConsolePro.config
+      end
+    end
+  end
+end
+

data/lib/rails_console_pro/commands.rb

@@ -45,5 +45,20 @@ module RailsConsolePro
     def snippets(action = :list, *args, **kwargs, &block)
       SnippetsCommand.new.execute(action, *args, **kwargs, &block)
     end
+
+    # Model introspection command
+    def introspect(model_class, *options)
+      IntrospectCommand.new.execute(model_class, *options)
+    end
+
+    # Query comparison command
+    def compare(&block)
+      CompareCommand.new.execute(&block)
+    end
+
+    # Query builder command
+    def query(model_class, &block)
+      QueryBuilderCommand.new.execute(model_class, &block)
+    end
   end
 end

data/lib/rails_console_pro/compare_result.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module RailsConsolePro
+  # Value object for query comparison results
+  class CompareResult
+    Comparison = Struct.new(
+      :name,
+      :duration_ms,
+      :query_count,
+      :result,
+      :error,
+      :sql_queries,
+      :memory_usage_kb,
+      keyword_init: true
+    )
+
+    attr_reader :comparisons, :winner, :timestamp
+
+    def initialize(comparisons:, winner: nil, timestamp: Time.current)
+      @comparisons = Array(comparisons)
+      @winner = winner
+      @timestamp = timestamp
+    end
+
+    def fastest
+      comparisons.min_by { |c| c.duration_ms || Float::INFINITY }
+    end
+
+    def slowest
+      comparisons.max_by { |c| c.duration_ms || 0 }
+    end
+
+    def has_errors?
+      comparisons.any? { |c| c.error }
+    end
+
+    def error_count
+      comparisons.count { |c| c.error }
+    end
+
+    def total_queries
+      comparisons.sum { |c| c.query_count || 0 }
+    end
+
+    def fastest_name
+      fastest&.name
+    end
+
+    def slowest_name
+      slowest&.name
+    end
+
+    def performance_ratio
+      return nil if comparisons.size < 2 || fastest.nil? || slowest.nil?
+      return nil if fastest.duration_ms.nil? || slowest.duration_ms.nil? || fastest.duration_ms.zero?
+
+      (slowest.duration_ms / fastest.duration_ms).round(2)
+    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: "Query 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/configuration.rb

@@ -51,6 +51,9 @@ module RailsConsolePro
     attr_accessor :snippets_command_enabled
     attr_accessor :profile_command_enabled
     attr_accessor :queue_command_enabled
+    attr_accessor :introspect_command_enabled
+    attr_accessor :compare_command_enabled
+    attr_accessor :query_builder_command_enabled
     attr_accessor :active_record_printer_enabled
     attr_accessor :relation_printer_enabled
     attr_accessor :collection_printer_enabled
@@ -99,6 +102,9 @@ module RailsConsolePro
       @snippets_command_enabled = true
       @profile_command_enabled = true
       @queue_command_enabled = true
+      @introspect_command_enabled = true
+      @compare_command_enabled = true
+      @query_builder_command_enabled = true
       @active_record_printer_enabled = true
       @relation_printer_enabled = true
       @collection_printer_enabled = true
@@ -212,6 +218,9 @@ module RailsConsolePro
       @stats_command_enabled = false
       @diff_command_enabled = false
       @queue_command_enabled = false
+      @introspect_command_enabled = false
+      @compare_command_enabled = false
+      @query_builder_command_enabled = false
       @active_record_printer_enabled = false
       @relation_printer_enabled = false
       @collection_printer_enabled = false
@@ -227,6 +236,9 @@ module RailsConsolePro
       @stats_command_enabled = true
       @diff_command_enabled = true
       @queue_command_enabled = true
+      @introspect_command_enabled = true
+      @compare_command_enabled = true
+      @query_builder_command_enabled = true
       @active_record_printer_enabled = true
       @relation_printer_enabled = true
       @collection_printer_enabled = true

data/lib/rails_console_pro/format_exporter.rb

@@ -83,6 +83,12 @@ module RailsConsolePro
         serialize_explain_result(data)
       when ProfileResult
         serialize_profile_result(data)
+      when IntrospectResult
+        serialize_introspect_result(data)
+      when CompareResult
+        serialize_compare_result(data)
+      when QueryBuilderResult
+        serialize_query_builder_result(data)
       when ActiveRecord::Base
         serialize_active_record(data)
       when ActiveRecord::Relation
@@ -137,6 +143,18 @@ module RailsConsolePro
       Serializers::ProfileSerializer.serialize(result, self)
     end
 
+    def serialize_introspect_result(result)
+      Serializers::IntrospectSerializer.serialize(result, self)
+    end
+
+    def serialize_compare_result(result)
+      Serializers::CompareSerializer.serialize(result, self)
+    end
+
+    def serialize_query_builder_result(result)
+      Serializers::QueryBuilderSerializer.serialize(result, self)
+    end
+
     def serialize_active_record(record)
       Serializers::ActiveRecordSerializer.serialize(record, self)
     end
@@ -396,6 +414,12 @@ module RailsConsolePro
         "SQL Explain Analysis"
       when ProfileResult
         "Profile: #{data.label || 'Session'}"
+      when IntrospectResult
+        "Introspection: #{data.model.name}"
+      when CompareResult
+        "Query Comparison (#{data.comparisons.size} strategies)"
+      when QueryBuilderResult
+        "Query Builder: #{data.model_class.name}"
       when ActiveRecord::Base
         "#{data.class.name} ##{data.id}"
       when ActiveRecord::Relation

data/lib/rails_console_pro/global_methods.rb

@@ -52,3 +52,15 @@ def snippets(action = :list, *args, **kwargs, &block)
   RailsConsolePro::Commands.snippets(action, *args, **kwargs, &block)
 end
 
+def introspect(model_class, *options)
+  RailsConsolePro::Commands.introspect(model_class, *options)
+end
+
+def compare(&block)
+  RailsConsolePro::Commands.compare(&block)
+end
+
+def query(model_class, &block)
+  RailsConsolePro::Commands.query(model_class, &block)
+end
+

data/lib/rails_console_pro/initializer.rb

@@ -33,6 +33,10 @@ module RailsConsolePro
   autoload :DiffResult,             "rails_console_pro/diff_result"
   autoload :ProfileResult,          "rails_console_pro/profile_result"
   autoload :QueueInsightsResult,    "rails_console_pro/queue_insights_result"
+  autoload :IntrospectResult,       "rails_console_pro/introspect_result"
+  autoload :CompareResult,          "rails_console_pro/compare_result"
+  autoload :QueryBuilderResult,     "rails_console_pro/query_builder_result"
+  autoload :QueryBuilder,           "rails_console_pro/query_builder"
   autoload :AssociationNavigator,  "rails_console_pro/association_navigator"
   autoload :Commands,               "rails_console_pro/commands"
   autoload :FormatExporter,         "rails_console_pro/format_exporter"
@@ -49,9 +53,12 @@ module RailsConsolePro
     autoload :StatsPrinter,         "rails_console_pro/printers/stats_printer"
     autoload :DiffPrinter,          "rails_console_pro/printers/diff_printer"
     autoload :ProfilePrinter,       "rails_console_pro/printers/profile_printer"
+    autoload :IntrospectPrinter,    "rails_console_pro/printers/introspect_printer"
     autoload :SnippetCollectionPrinter, "rails_console_pro/printers/snippet_collection_printer"
     autoload :SnippetPrinter,           "rails_console_pro/printers/snippet_printer"
     autoload :QueueInsightsPrinter, "rails_console_pro/printers/queue_insights_printer"
+    autoload :ComparePrinter,      "rails_console_pro/printers/compare_printer"
+    autoload :QueryBuilderPrinter, "rails_console_pro/printers/query_builder_printer"
   end
 
   # Main dispatcher - optimized with early returns
@@ -96,7 +103,10 @@ module RailsConsolePro
     return Printers::StatsPrinter if value.is_a?(StatsResult)
     return Printers::DiffPrinter if value.is_a?(DiffResult)
     return Printers::ProfilePrinter if value.is_a?(ProfileResult)
+    return Printers::IntrospectPrinter if value.is_a?(IntrospectResult)
     return Printers::QueueInsightsPrinter if value.is_a?(QueueInsightsResult)
+    return Printers::ComparePrinter if value.is_a?(CompareResult)
+    return Printers::QueryBuilderPrinter if value.is_a?(QueryBuilderResult)
     if defined?(Snippets::CollectionResult) && value.is_a?(Snippets::CollectionResult)
       return Printers::SnippetCollectionPrinter
     end
@@ -158,6 +168,7 @@ require_relative 'services/profile_collector'
 require_relative 'services/snippet_repository'
 require_relative 'services/queue_action_service'
 require_relative 'services/queue_insight_fetcher'
+require_relative 'services/introspection_collector'
 
 # Load command classes (needed by Commands module)
 require_relative 'commands/base_command'
@@ -166,9 +177,12 @@ require_relative 'commands/explain_command'
 require_relative 'commands/stats_command'
 require_relative 'commands/diff_command'
 require_relative 'commands/export_command'
+require_relative 'commands/introspect_command'
 require_relative 'commands/snippets_command'
 require_relative 'commands/profile_command'
 require_relative 'commands/jobs_command'
+require_relative 'commands/compare_command'
+require_relative 'commands/query_builder_command'
 
 # Load Commands module (uses command classes)
 require_relative 'commands'
@@ -180,6 +194,9 @@ require_relative 'serializers/stats_serializer'
 require_relative 'serializers/explain_serializer'
 require_relative 'serializers/diff_serializer'
 require_relative 'serializers/profile_serializer'
+require_relative 'serializers/introspect_serializer'
+require_relative 'serializers/compare_serializer'
+require_relative 'serializers/query_builder_serializer'
 require_relative 'serializers/active_record_serializer'
 require_relative 'serializers/relation_serializer'
 require_relative 'serializers/array_serializer'
@@ -196,6 +213,6 @@ end
 if RailsConsolePro.config.show_welcome_message && defined?(Pry)
   pastel = RailsConsolePro::PASTEL
   puts pastel.bright_green("🚀 Rails Console Pro Loaded!")
-  puts pastel.cyan("📊 Use `schema ModelName`, `explain Query`, `stats ModelName`, `diff obj1, obj2`, or `navigate ModelName`")
+  puts pastel.cyan("📊 Use `schema`, `explain`, `stats`, `introspect`, `diff`, `navigate`, `profile`, or `jobs` commands")
   puts pastel.dim("💾 Export support: Use `.to_json`, `.to_yaml`, `.to_html`, or `.export_to_file` on any result")
 end

data/lib/rails_console_pro/introspect_result.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module RailsConsolePro
+  # Value object for model introspection results
+  class IntrospectResult
+    attr_reader :model, :callbacks, :enums, :concerns, :scopes, 
+                :validations, :lifecycle_hooks, :timestamp
+
+    def initialize(model:, callbacks: {}, enums: {}, concerns: [], 
+                   scopes: {}, validations: [], lifecycle_hooks: {},
+                   timestamp: Time.current)
+      @model = model
+      @callbacks = callbacks
+      @enums = enums
+      @concerns = concerns
+      @scopes = scopes
+      @validations = validations
+      @lifecycle_hooks = lifecycle_hooks
+      @timestamp = timestamp
+      validate_model!
+    end
+
+    def ==(other)
+      other.is_a?(self.class) && other.model == model && other.timestamp == timestamp
+    end
+
+    # Query methods
+    def has_callbacks?
+      callbacks.any?
+    end
+
+    def has_enums?
+      enums.any?
+    end
+
+    def has_concerns?
+      concerns.any?
+    end
+
+    def has_scopes?
+      scopes.any?
+    end
+
+    def has_validations?
+      validations.any?
+    end
+
+    # Get callbacks by type
+    def callbacks_by_type(type)
+      callbacks[type] || []
+    end
+
+    # Get validations for attribute
+    def validations_for(attribute)
+      validations[attribute] || []
+    end
+
+    # Get enum values
+    def enum_values(enum_name)
+      enums.dig(enum_name.to_s, :values) || []
+    end
+
+    # Get scope SQL
+    def scope_sql(scope_name)
+      scopes.dig(scope_name.to_sym, :sql)
+    end
+
+    # Get method source location
+    def method_source(method_name)
+      collector = Services::IntrospectionCollector.new(model)
+      collector.method_source_location(method_name)
+    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: "Introspection: #{model.name}", style: style)
+    end
+
+    # Export to file
+    def export_to_file(file_path, format: nil)
+      FormatExporter.export_to_file(self, file_path, format: format)
+    end
+
+    private
+
+    def validate_model!
+      ModelValidator.validate_model!(model)
+    end
+  end
+end
+