rails_console_pro 0.1.3 → 0.1.4

data/lib/rails_console_pro/printers/compare_printer.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+module RailsConsolePro
+  module Printers
+    # Printer for query comparison results
+    class ComparePrinter < BasePrinter
+      def print
+        print_header
+        print_summary
+        print_comparisons
+        print_winner
+        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, "⚖️  QUERY COMPARISON")
+        output.puts bold_color(header_color, "═" * config.header_width)
+      end
+
+      def print_summary
+        output.puts bold_color(config.get_color(:warning), "\n📊 Summary:")
+        output.puts "  Total Strategies: #{color(config.get_color(:attribute_value_numeric), value.comparisons.size)}"
+        output.puts "  Fastest: #{color(config.get_color(:success), value.fastest_name || 'N/A')}"
+        output.puts "  Slowest: #{color(config.get_color(:error), value.slowest_name || 'N/A')}"
+        
+        if value.performance_ratio
+          ratio = value.performance_ratio
+          ratio_color = ratio > 2 ? config.get_color(:error) : config.get_color(:warning)
+          output.puts "  Performance Ratio: #{color(ratio_color, "#{ratio}x slower")}"
+        end
+
+        if value.has_errors?
+          output.puts "  Errors: #{color(config.get_color(:error), value.error_count.to_s)}"
+        end
+      end
+
+      def print_comparisons
+        output.puts bold_color(config.get_color(:warning), "\n📈 Detailed Results:")
+        
+        sorted = value.comparisons.sort_by { |c| c.duration_ms || Float::INFINITY }
+        
+        sorted.each_with_index do |comparison, index|
+          print_comparison(comparison, index + 1, sorted.size)
+        end
+      end
+
+      def print_comparison(comparison, rank, total)
+        is_winner = comparison == value.fastest
+        rank_color = is_winner ? config.get_color(:success) : config.get_color(:attribute_value_string)
+        
+        output.puts "\n  #{color(rank_color, "##{rank}")} #{bold_color(rank_color, comparison.name)}"
+        
+        if comparison.error
+          output.puts "    #{color(config.get_color(:error), "❌ Error: #{comparison.error.class} - #{comparison.error.message}")}"
+          return
+        end
+
+        # Duration
+        duration_str = format_duration(comparison.duration_ms)
+        output.puts "    ⏱️  Duration: #{duration_str}"
+
+        # Query count
+        query_color = comparison.query_count > 10 ? config.get_color(:error) : 
+                      comparison.query_count > 1 ? config.get_color(:warning) : 
+                      config.get_color(:success)
+        output.puts "    🔢 Queries: #{color(query_color, comparison.query_count.to_s)}"
+
+        # Memory usage
+        if comparison.memory_usage_kb && comparison.memory_usage_kb > 0
+          memory_str = format_memory(comparison.memory_usage_kb)
+          output.puts "    💾 Memory: #{color(config.get_color(:info), memory_str)}"
+        end
+
+        # SQL queries preview
+        if comparison.sql_queries&.any?
+          preview_count = [comparison.sql_queries.size, 3].min
+          output.puts "    📝 SQL Queries (#{comparison.sql_queries.size} total):"
+          comparison.sql_queries.first(preview_count).each_with_index do |query_info, idx|
+            sql_preview = truncate_sql(query_info[:sql], 60)
+            duration = query_info[:duration_ms]
+            cached = query_info[:cached] ? " (cached)" : ""
+            output.puts "      #{idx + 1}. #{color(config.get_color(:attribute_value_string), sql_preview)} #{color(config.get_color(:border), "(#{duration}ms#{cached})")}"
+          end
+          if comparison.sql_queries.size > preview_count
+            output.puts "      ... and #{comparison.sql_queries.size - preview_count} more"
+          end
+        end
+      end
+
+      def print_winner
+        return unless value.winner
+
+        output.puts bold_color(config.get_color(:success), "\n🏆 Winner: #{value.winner.name}")
+        if value.performance_ratio && value.performance_ratio > 1
+          output.puts "   #{color(config.get_color(:info), "This strategy is #{value.performance_ratio.round(1)}x faster than the slowest")}"
+        end
+      end
+
+      def print_footer
+        footer_color = config.get_color(:footer)
+        output.puts bold_color(footer_color, "═" * config.header_width)
+      end
+
+      def format_duration(ms)
+        return color(config.get_color(:attribute_value_nil), "N/A") unless ms
+
+        case ms
+        when 0...10
+          color(config.get_color(:success), "#{ms.round(2)}ms")
+        when 10...100
+          color(config.get_color(:warning), "#{ms.round(2)}ms")
+        else
+          color(config.get_color(:error), "#{ms.round(2)}ms")
+        end
+      end
+
+      def format_memory(kb)
+        if kb < 1024
+          "#{kb.round(2)} KB"
+        elsif kb < 1024 * 1024
+          "#{(kb / 1024.0).round(2)} MB"
+        else
+          "#{(kb / (1024.0 * 1024.0)).round(2)} GB"
+        end
+      end
+
+      def truncate_sql(sql, max_length)
+        return sql if sql.length <= max_length
+        "#{sql[0, max_length - 3]}..."
+      end
+    end
+  end
+end
+

data/lib/rails_console_pro/printers/introspect_printer.rb

@@ -0,0 +1,282 @@
+# frozen_string_literal: true
+
+module RailsConsolePro
+  module Printers
+    # Printer for model introspection results
+    class IntrospectPrinter < BasePrinter
+      def print
+        print_header
+        print_lifecycle_summary
+        print_callbacks
+        print_validations
+        print_enums
+        print_scopes
+        print_concerns
+        print_footer
+      end
+
+      private
+
+      def print_header
+        model = value.model
+        header_color = config.get_color(:header)
+        output.puts bold_color(header_color, "═" * config.header_width)
+        output.puts bold_color(header_color, "🔍 MODEL INTROSPECTION: #{model.name}")
+        output.puts bold_color(header_color, "═" * config.header_width)
+      end
+
+      def print_lifecycle_summary
+        hooks = value.lifecycle_hooks
+        return if hooks.empty?
+
+        output.puts bold_color(config.get_color(:warning), "\n📊 Lifecycle Summary:")
+        
+        output.puts "  Callbacks: #{bold_color(config.get_color(:attribute_value_numeric), hooks[:callbacks_count].to_s)}"
+        output.puts "  Validations: #{bold_color(config.get_color(:attribute_value_numeric), hooks[:validations_count].to_s)}"
+        
+        if hooks[:has_state_machine]
+          output.puts "  #{bold_color(config.get_color(:success), '✓')} Has state machine"
+        end
+        
+        if hooks[:has_observers]
+          output.puts "  #{bold_color(config.get_color(:success), '✓')} Has observers"
+        end
+      end
+
+      def print_callbacks
+        return unless value.has_callbacks?
+
+        output.puts bold_color(config.get_color(:warning), "\n🔔 Callbacks:")
+        
+        value.callbacks.each do |type, chain|
+          next if chain.empty?
+          
+          type_color = callback_type_color(type)
+          output.puts "\n  #{bold_color(type_color, type.to_s)} (#{chain.size}):"
+          
+          chain.each_with_index do |callback, index|
+            print_callback(callback, index + 1)
+          end
+        end
+      end
+
+      def print_callback(callback, index)
+        name_color = config.get_color(:attribute_key)
+        output.print "    #{color(:dim, "#{index}.")} #{bold_color(name_color, callback[:name])}"
+        
+        # Print conditions
+        conditions = []
+        if callback[:if]
+          conditions << "#{color(config.get_color(:success), 'if')}: #{callback[:if].join(', ')}"
+        end
+        if callback[:unless]
+          conditions << "#{color(config.get_color(:error), 'unless')}: #{callback[:unless].join(', ')}"
+        end
+        
+        unless conditions.empty?
+          output.print " #{color(:dim, '(')}#{conditions.join(', ')}#{color(:dim, ')')}"
+        end
+        
+        output.puts
+      end
+
+      def print_validations
+        return unless value.has_validations?
+
+        output.puts bold_color(config.get_color(:warning), "\n✅ Validations:")
+        
+        value.validations.each do |attribute, validators|
+          next if validators.empty?
+          
+          attr_color = config.get_color(:attribute_key)
+          output.puts "\n  #{bold_color(attr_color, attribute.to_s)}:"
+          
+          validators.each do |validator|
+            print_validator(validator)
+          end
+        end
+      end
+
+      def print_validator(validator)
+        validator_color = get_validator_color(validator[:type])
+        output.print "    #{bold_color(validator_color, validator[:type])}"
+        
+        # Print options
+        unless validator[:options].empty?
+          opts = validator[:options].map do |key, val|
+            "#{key}: #{format_validator_value(val)}"
+          end.join(', ')
+          output.print " #{color(:dim, '(')}#{opts}#{color(:dim, ')')}"
+        end
+        
+        # Print conditions
+        unless validator[:conditions].empty?
+          conds = validator[:conditions].map do |key, val|
+            "#{key}: #{val}"
+          end.join(', ')
+          output.print " [#{color(config.get_color(:info), conds)}]"
+        end
+        
+        output.puts
+      end
+
+      def print_enums
+        return unless value.has_enums?
+
+        output.puts bold_color(config.get_color(:warning), "\n🔢 Enums:")
+        
+        value.enums.each do |name, data|
+          enum_color = config.get_color(:attribute_key)
+          type_badge = format_enum_type_badge(data[:type])
+          
+          output.puts "\n  #{bold_color(enum_color, name)} #{type_badge}:"
+          
+          # Print values in a compact format
+          values = data[:values].map { |v| color(config.get_color(:success), v) }
+          output.puts "    #{values.join(', ')}"
+          
+          # Show mapping preview for first few
+          if data[:mapping].size <= 5
+            mapping = data[:mapping].map do |k, v|
+              "#{color(config.get_color(:attribute_key), k)} => #{color(config.get_color(:attribute_value_numeric), v)}"
+            end.join(', ')
+            output.puts "    #{color(:dim, "Mapping: #{mapping}")}"
+          end
+        end
+      end
+
+      def print_scopes
+        return unless value.has_scopes?
+
+        output.puts bold_color(config.get_color(:warning), "\n🔭 Scopes:")
+        
+        value.scopes.each do |name, data|
+          scope_color = config.get_color(:attribute_key)
+          output.puts "\n  #{bold_color(scope_color, name.to_s)}:"
+          
+          # Print SQL with syntax highlighting
+          sql = data[:sql]
+          output.puts "    #{color(:dim, '└─ SQL:')} #{color(config.get_color(:info), truncate_sql(sql))}"
+          
+          # Print scope values if interesting
+          unless data[:values].empty?
+            data[:values].each do |key, value|
+              next if value.nil? || value.to_s.empty?
+              output.puts "    #{color(:dim, '└─')} #{color(config.get_color(:attribute_key), key.to_s)}: #{format_value(value)}"
+            end
+          end
+        end
+      end
+
+      def print_concerns
+        return unless value.has_concerns?
+
+        output.puts bold_color(config.get_color(:warning), "\n📦 Concerns & Modules:")
+        
+        # Group by type
+        by_type = value.concerns.group_by { |c| c[:type] }
+        
+        [:concern, :class, :module].each do |type|
+          items = by_type[type]
+          next unless items && items.any?
+          
+          type_label = type.to_s.capitalize.pluralize
+          output.puts "\n  #{bold_color(config.get_color(:info), type_label)}:"
+          
+          items.each do |concern|
+            print_concern(concern)
+          end
+        end
+      end
+
+      def print_concern(concern)
+        name_color = config.get_color(:attribute_key)
+        type_badge = format_concern_badge(concern[:type])
+        
+        output.print "    #{type_badge} #{bold_color(name_color, concern[:name])}"
+        
+        if concern[:location]
+          file = concern[:location][:file]
+          line = concern[:location][:line]
+          # Show relative path if possible
+          display_path = file.include?(Rails.root.to_s) ? file.sub(Rails.root.to_s + '/', '') : file rescue file
+          output.print " #{color(:dim, "#{display_path}:#{line}")}"
+        end
+        
+        output.puts
+      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')}")
+        
+        # Print helpful tips
+        output.puts "\n#{color(config.get_color(:info), '💡 Tip:')} Use #{color(:cyan, 'introspect Model, :callbacks')} to see only callbacks"
+        output.puts "       Use #{color(:cyan, 'introspect Model, :method_name')} to find where a method is defined"
+      end
+
+      # Helper methods
+      def callback_type_color(type)
+        case type
+        when :before_validation, :before_save, :before_create, :before_update, :before_destroy
+          :yellow
+        when :after_validation, :after_save, :after_create, :after_update, :after_destroy, :after_commit
+          :green
+        when :around_save, :around_create, :around_update, :around_destroy
+          :cyan
+        else
+          :blue
+        end
+      end
+
+      def get_validator_color(validator_type)
+        colors = config.validator_colors
+        colors[validator_type] || config.get_color(:attribute_key)
+      end
+
+      def format_validator_value(val)
+        case val
+        when Array
+          val.map { |v| color(config.get_color(:success), v.to_s) }.join(', ')
+        when Range
+          "#{val.first}..#{val.last}"
+        when Regexp
+          color(config.get_color(:info), val.inspect)
+        else
+          format_value(val)
+        end
+      end
+
+      def format_enum_type_badge(type)
+        case type
+        when :integer
+          color(config.get_color(:attribute_value_numeric), '[Integer]')
+        when :string
+          color(config.get_color(:attribute_value_string), '[String]')
+        else
+          color(:dim, '[Unknown]')
+        end
+      end
+
+      def format_concern_badge(type)
+        case type
+        when :concern
+          bold_color(config.get_color(:success), '●')
+        when :class
+          bold_color(config.get_color(:info), '▪')
+        when :module
+          bold_color(config.get_color(:warning), '○')
+        else
+          color(:dim, '·')
+        end
+      end
+
+      def truncate_sql(sql, max_length = 80)
+        return sql if sql.length <= max_length
+        "#{sql[0...max_length]}..."
+      end
+    end
+  end
+end
+

data/lib/rails_console_pro/printers/query_builder_printer.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module RailsConsolePro
+  module Printers
+    # Printer for query builder results
+    class QueryBuilderPrinter < BasePrinter
+      def print
+        print_header
+        print_error if has_error?
+        print_query unless has_error?
+        print_statistics
+        print_explain if value.explain_result
+        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, "🔧 QUERY BUILDER: #{value.model_class.name}")
+        output.puts bold_color(header_color, "═" * config.header_width)
+      end
+
+      def print_query
+        output.puts bold_color(config.get_color(:warning), "\n📝 Generated SQL:")
+        output.puts color(config.get_color(:attribute_value_string), value.sql)
+      end
+
+      def print_statistics
+        return if value.statistics.empty?
+
+        output.puts bold_color(config.get_color(:warning), "\n📊 Statistics:")
+        value.statistics.each do |key, val|
+          next if key == "SQL" # Already shown above
+          key_color = config.get_color(:attribute_key)
+          output.puts "  #{bold_color(key_color, key.to_s.ljust(20))} #{color(config.get_color(:attribute_value_string), val.to_s)}"
+        end
+      end
+
+      def print_explain
+        return unless value.explain_result
+
+        output.puts bold_color(config.get_color(:warning), "\n🔬 Query Analysis:")
+        
+        explain_printer = ExplainPrinter.new(output, value.explain_result, nil)
+        explain_printer.print
+      end
+
+      def print_footer
+        footer_color = config.get_color(:footer)
+        output.puts bold_color(footer_color, "═" * config.header_width)
+        output.puts color(config.get_color(:info), "\n💡 Tip: Use .execute to run the query, or .to_a to get results") unless has_error?
+      end
+
+      def has_error?
+        value.statistics && value.statistics["Error"]
+      end
+
+      def print_error
+        error_msg = value.statistics["Error"]
+        output.puts bold_color(config.get_color(:error), "\n❌ Query Error:")
+        output.puts color(config.get_color(:error), "  #{error_msg}")
+        
+        # Provide helpful hints for common errors
+        if error_msg.include?("polymorphic")
+          output.puts color(config.get_color(:warning), "\n💡 Tip: Polymorphic associations have limitations:")
+          output.puts color(config.get_color(:info), "   - For eager loading: use 'preload' instead of 'includes'")
+          output.puts color(config.get_color(:info), "   - For joins: filter by polymorphic columns (channel_id, channel_type)")
+          output.puts color(config.get_color(:info), "   - Or use raw SQL joins: joins(\"INNER JOIN ...\")")
+        elsif error_msg.include?("ambiguous")
+          output.puts color(config.get_color(:warning), "\n💡 Tip: When joining tables, qualify column names with table names.")
+          output.puts color(config.get_color(:info), "   Example: where('table_name.column_name > ?', value)")
+        elsif error_msg.include?("ActiveRecord") || error_msg.include?("association")
+          output.puts color(config.get_color(:warning), "\n💡 Tip: Check that associations are defined correctly in your model.")
+        end
+      end
+    end
+  end
+end
+

data/lib/rails_console_pro/query_builder.rb

@@ -0,0 +1,197 @@
+# frozen_string_literal: true
+
+module RailsConsolePro
+  # DSL for building and analyzing ActiveRecord queries
+  class QueryBuilder
+    def initialize(model_class)
+      unless model_class.respond_to?(:all)
+        raise ArgumentError, "#{model_class} is not an ActiveRecord model"
+      end
+      @model_class = model_class
+      @relation = model_class.all
+    end
+
+    # Chainable query methods
+    def where(*args, **kwargs)
+      @relation = @relation.where(*args, **kwargs)
+      self
+    end
+
+    def includes(*args)
+      @relation = @relation.includes(*args)
+      self
+    end
+
+    def preload(*args)
+      @relation = @relation.preload(*args)
+      self
+    end
+
+    def eager_load(*args)
+      @relation = @relation.eager_load(*args)
+      self
+    end
+
+    def joins(*args)
+      @relation = @relation.joins(*args)
+      self
+    end
+
+    def left_joins(*args)
+      @relation = @relation.left_joins(*args)
+      self
+    end
+
+    def left_outer_joins(*args)
+      @relation = @relation.left_outer_joins(*args)
+      self
+    end
+
+    def select(*args)
+      @relation = @relation.select(*args)
+      self
+    end
+
+    def order(*args)
+      @relation = @relation.order(*args)
+      self
+    end
+
+    def limit(value)
+      @relation = @relation.limit(value)
+      self
+    end
+
+    def offset(value)
+      @relation = @relation.offset(value)
+      self
+    end
+
+    def group(*args)
+      @relation = @relation.group(*args)
+      self
+    end
+
+    def having(*args)
+      @relation = @relation.having(*args)
+      self
+    end
+
+    def distinct(value = true)
+      @relation = @relation.distinct(value)
+      self
+    end
+
+    def readonly(value = true)
+      @relation = @relation.readonly(value)
+      self
+    end
+
+    def lock(locks = true)
+      @relation = @relation.lock(locks)
+      self
+    end
+
+    def reorder(*args)
+      @relation = @relation.reorder(*args)
+      self
+    end
+
+    def reverse_order
+      @relation = @relation.reverse_order
+      self
+    end
+
+    def unscope(*args)
+      @relation = @relation.unscope(*args)
+      self
+    end
+
+    def rewhere(conditions)
+      @relation = @relation.rewhere(conditions)
+      self
+    end
+
+    # Analyze the query (returns QueryBuilderResult with explain)
+    def analyze
+      begin
+        sql = @relation.to_sql
+        statistics = build_statistics
+        result = QueryBuilderResult.new(
+          relation: @relation,
+          sql: sql,
+          statistics: statistics,
+          model_class: @model_class
+        )
+        result.analyze
+      rescue => e
+        # Return a result with error information
+        QueryBuilderResult.new(
+          relation: @relation,
+          sql: nil,
+          statistics: { "Model" => @model_class.name, "Table" => @model_class.table_name, "Error" => e.message },
+          model_class: @model_class
+        )
+      end
+    end
+
+    # Build the query and return result without explain
+    def build
+      begin
+        sql = @relation.to_sql
+        statistics = build_statistics
+        QueryBuilderResult.new(
+          relation: @relation,
+          sql: sql,
+          statistics: statistics,
+          model_class: @model_class
+        )
+      rescue => e
+        # Return a result with error information
+        QueryBuilderResult.new(
+          relation: @relation,
+          sql: nil,
+          statistics: { "Model" => @model_class.name, "Table" => @model_class.table_name, "Error" => e.message },
+          model_class: @model_class
+        )
+      end
+    end
+
+    # Execute the query and return the relation
+    def execute
+      @relation
+    end
+
+    # Delegate other methods to the relation
+    def method_missing(method_name, *args, **kwargs, &block)
+      if @relation.respond_to?(method_name)
+        result = @relation.public_send(method_name, *args, **kwargs, &block)
+        # If result is a relation, return self for chaining
+        if result.is_a?(ActiveRecord::Relation) && result.klass == @model_class
+          @relation = result
+          self
+        else
+          result
+        end
+      else
+        super
+      end
+    end
+
+    def respond_to_missing?(method_name, include_private = false)
+      @relation.respond_to?(method_name, include_private) || super
+    end
+
+    private
+
+    def build_statistics
+      {
+        "Model" => @model_class.name,
+        "Table" => @model_class.table_name,
+        "SQL" => @relation.to_sql
+      }
+    end
+
+  end
+end
+