rails_console_pro 0.1.0

data/lib/rails_console_pro/active_record_extensions.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+module RailsConsolePro
+  # ActiveRecord extensions for export functionality
+  module ActiveRecordExtensions
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      # Export schema to file
+      def export_schema_to_file(file_path, format: nil)
+        result = Commands.schema(self)
+        result&.export_to_file(file_path, format: format)
+      end
+
+      # Export schema to JSON
+      def schema_to_json(pretty: true)
+        result = Commands.schema(self)
+        result&.to_json(pretty: pretty)
+      end
+
+      # Export schema to YAML
+      def schema_to_yaml
+        result = Commands.schema(self)
+        result&.to_yaml
+      end
+
+      # Export schema to HTML
+      def schema_to_html(style: :default)
+        result = Commands.schema(self)
+        result&.to_html(style: style)
+      end
+    end
+
+    # Export record to JSON
+    def to_json_export(pretty: true)
+      FormatExporter.to_json(self, pretty: pretty)
+    end
+
+    # Export record to YAML
+    def to_yaml_export
+      FormatExporter.to_yaml(self)
+    end
+
+    # Export record to HTML
+    def to_html_export(style: :default)
+      FormatExporter.to_html(self, title: "#{self.class.name} ##{id}", style: style)
+    end
+
+    # Export record to file
+    def export_to_file(file_path, format: nil)
+      FormatExporter.export_to_file(self, file_path, format: format)
+    end
+  end
+
+  # ActiveRecord::Relation extensions
+  module RelationExtensions
+    # Export relation to JSON
+    def to_json_export(pretty: true)
+      FormatExporter.to_json(self, pretty: pretty)
+    end
+
+    # Export relation to YAML
+    def to_yaml_export
+      FormatExporter.to_yaml(self)
+    end
+
+    # Export relation to HTML
+    def to_html_export(style: :default)
+      FormatExporter.to_html(self, title: "#{klass.name} Collection (#{count} records)", style: style)
+    end
+
+    # Export relation to file
+    def export_to_file(file_path, format: nil)
+      FormatExporter.export_to_file(self, file_path, format: format)
+    end
+  end
+
+  # Array extensions for ActiveRecord collections
+  module ArrayExtensions
+    # Export array to JSON
+    def to_json_export(pretty: true)
+      FormatExporter.to_json(self, pretty: pretty)
+    end
+
+    # Export array to YAML
+    def to_yaml_export
+      FormatExporter.to_yaml(self)
+    end
+
+    # Export array to HTML
+    def to_html_export(style: :default)
+      title = if !empty? && first.is_a?(ActiveRecord::Base)
+                "#{first.class.name} Collection (#{size} records)"
+              else
+                "Array (#{size} items)"
+              end
+      FormatExporter.to_html(self, title: title, style: style)
+    end
+
+    # Export array to file
+    def export_to_file(file_path, format: nil)
+      FormatExporter.export_to_file(self, file_path, format: format)
+    end
+  end
+end
+
+# Include extensions in ActiveRecord (only if ActiveRecord is loaded)
+if defined?(ActiveRecord::Base)
+  ActiveRecord::Base.include(RailsConsolePro::ActiveRecordExtensions)
+  ActiveRecord::Relation.include(RailsConsolePro::RelationExtensions)
+  Array.include(RailsConsolePro::ArrayExtensions)
+end
+

data/lib/rails_console_pro/association_navigator.rb

@@ -0,0 +1,273 @@
+# frozen_string_literal: true
+
+module RailsConsolePro
+  # Interactive association navigator
+  class AssociationNavigator
+    include ColorHelper
+
+    ASSOCIATION_ICONS = {
+      belongs_to: "↖️",
+      has_one: "→",
+      has_many: "⇒",
+      has_and_belongs_to_many: "⇔"
+    }.freeze
+
+    attr_reader :model, :history
+
+    def initialize(model)
+      @model = resolve_model(model)
+      @history = []
+      validate_model!
+    end
+
+    def start
+      current_model = @model
+      loop do
+        display_menu(current_model)
+        choice = get_user_choice(current_model)
+        
+        break if choice == :exit
+        next handle_back(current_model) if choice == :back
+        next unless choice
+        
+        @history.push(current_model)
+        current_model = navigate_to(current_model, choice)
+      end
+    end
+
+    private
+
+    def resolve_model(model_or_string)
+      return model_or_string unless model_or_string.is_a?(String)
+      
+      begin
+        model_or_string.constantize
+      rescue NameError
+        raise ArgumentError, "Could not find model '#{model_or_string}'"
+      end
+    end
+
+    def validate_model!
+      ModelValidator.validate_model!(@model)
+    end
+
+    def display_menu(model)
+      puts pastel.bright_cyan.bold("\n" + "═" * 70)
+      puts pastel.bright_cyan.bold("🧭 ASSOCIATION NAVIGATOR")
+      puts pastel.bright_cyan.bold("═" * 70)
+      
+      print_breadcrumb(model)
+      print_model_info(model)
+      print_associations_menu(model)
+      print_navigation_options
+      puts pastel.cyan("\n" + "─" * 70)
+    end
+
+    def print_breadcrumb(model)
+      breadcrumb = @history.map(&:name).join(" → ")
+      breadcrumb += " → " unless breadcrumb.empty?
+      breadcrumb += pastel.bright_green.bold(model.name)
+      
+      puts pastel.yellow.bold("\n📍 Current Location:")
+      puts "   #{breadcrumb}"
+    end
+
+    def print_model_info(model)
+      return unless model.respond_to?(:count)
+      
+      count = model.count rescue "?"
+      puts pastel.dim("   (#{count} records in database)")
+    end
+
+    def print_associations_menu(model)
+      associations = get_all_associations(model)
+      
+      if associations.empty?
+        puts pastel.red("   No associations found for this model")
+        return
+      end
+
+      puts pastel.yellow.bold("\n🔗 Available Associations:")
+      @menu_items = []
+      
+      group_associations(associations).each do |macro, group|
+        print_association_group(macro, group)
+      end
+    end
+
+    def group_associations(associations)
+      associations.group_by(&:macro)
+    end
+
+    def print_association_group(macro, associations)
+      return if associations.empty?
+      
+      puts pastel.cyan("\n  #{macro}:")
+      associations.each_with_index do |assoc, index|
+        menu_index = @menu_items.length + 1
+        @menu_items << assoc
+        
+        icon = ASSOCIATION_ICONS[macro] || "•"
+        details = format_association_details(assoc, model)
+        
+        puts "   #{pastel.bright_blue.bold(menu_index.to_s.rjust(2))}. #{icon}  " \
+             "#{pastel.white.bold(assoc.name.to_s)} → #{pastel.green(assoc.class_name)}#{details}"
+      end
+    end
+
+    def format_association_details(assoc, model)
+      details = []
+      details << pastel.dim(" [#{assoc.foreign_key}]") if assoc.respond_to?(:foreign_key)
+      details << pastel.dim(" (optional)") if assoc.options[:optional]
+      details << pastel.yellow(" (#{assoc.options[:dependent]})") if assoc.options[:dependent]
+      details << pastel.magenta(" through :#{assoc.options[:through]}") if assoc.options[:through]
+      details << pastel.dim(" [#{assoc.join_table}]") if assoc.respond_to?(:join_table) && assoc.join_table
+      
+      # Try to get count for has_many associations
+      if assoc.macro == :has_many && model.respond_to?(:first)
+        count_str = get_association_count(model, assoc)
+        details << count_str if count_str
+      end
+      
+      details.join
+    end
+
+    def get_association_count(model, assoc)
+      return nil unless model.respond_to?(:first)
+      
+      sample = model.first
+      return nil unless sample
+      
+      count = sample.send(assoc.name).count rescue nil
+      return nil unless count
+      
+      pastel.dim(" [~#{count} per record]")
+    end
+
+    def print_navigation_options
+      puts pastel.yellow.bold("\n📌 Navigation Options:")
+      puts "   #{pastel.bright_blue.bold('b')}  - Go back to previous model" if @history.any?
+      puts "   #{pastel.bright_blue.bold('q')}  - Exit navigator"
+      puts "   #{pastel.bright_blue.bold('s')}  - Show sample records for current model"
+      puts "   #{pastel.bright_blue.bold('c')}  - Show count for all associations"
+    end
+
+    def get_all_associations(model)
+      klass = model.is_a?(Class) ? model : model.klass
+      
+      [:belongs_to, :has_one, :has_many, :has_and_belongs_to_many].flat_map do |macro|
+        klass.reflect_on_all_associations(macro)
+      end
+    end
+
+    def get_user_choice(model)
+      print pastel.bright_green("\n➤ Enter choice: ")
+      input = gets.chomp.downcase.strip
+      
+      return :exit if input == 'q'
+      return :back if input == 'b'
+      return handle_sample_records(model) if input == 's'
+      return handle_association_counts(model) if input == 'c'
+      
+      resolve_choice(input)
+    end
+
+    def resolve_choice(input)
+      if input.match?(/^\d+$/)
+        index = input.to_i - 1
+        return @menu_items[index] if index >= 0 && index < @menu_items.length
+        
+        puts pastel.red("Invalid choice. Please select a number from the menu.")
+        nil
+      else
+        assoc = @menu_items.find { |a| a.name.to_s == input }
+        assoc || (puts pastel.red("Invalid choice.") && nil)
+      end
+    end
+
+    def handle_back(current_model)
+      if @history.any?
+        @history.pop
+      else
+        puts pastel.yellow("Already at the starting model")
+      end
+    end
+
+    def navigate_to(current_model, association)
+      klass = current_model.is_a?(Class) ? current_model : current_model.klass
+      target_class = association.class_name.constantize
+      
+      puts pastel.green("\n✅ Navigating to #{target_class.name}...")
+      target_class
+    rescue NameError => e
+      puts pastel.red("❌ Error: Could not find model #{association.class_name}")
+      puts pastel.yellow("   Make sure the model is loaded and defined.")
+      current_model
+    rescue => e
+      puts pastel.red("❌ Error navigating: #{e.message}")
+      current_model
+    end
+
+    def handle_sample_records(model)
+      klass = model.is_a?(Class) ? model : model.klass
+      
+      puts pastel.bright_magenta.bold("\n📋 Sample Records from #{klass.name}:")
+      puts pastel.dim("─" * 60)
+      
+      records = klass.limit(3).to_a
+      
+      if records.empty?
+        puts pastel.yellow("  No records found in database")
+      else
+        records.each_with_index do |record, index|
+          puts pastel.cyan("\n  Record ##{index + 1} (ID: #{record.id}):")
+          display_record_attributes(record)
+        end
+      end
+      
+      puts pastel.dim("─" * 60)
+      nil
+    end
+
+    def display_record_attributes(record)
+      display_attrs = record.attributes.first(5)
+      display_attrs.each do |key, value|
+        value_str = value.nil? ? pastel.dim("nil") : value.to_s.truncate(50)
+        puts "    #{pastel.blue(key)}: #{pastel.white(value_str)}"
+      end
+      
+      if record.attributes.size > 5
+        puts pastel.dim("    ... and #{record.attributes.size - 5} more attributes")
+      end
+    end
+
+    def handle_association_counts(model)
+      klass = model.is_a?(Class) ? model : model.klass
+      
+      puts pastel.bright_magenta.bold("\n📊 Association Counts for #{klass.name}:")
+      puts pastel.dim("─" * 60)
+      
+      sample = klass.first
+      unless sample
+        puts pastel.yellow("  No records to analyze")
+        return nil
+      end
+      
+      associations = get_all_associations(model)
+      associations.each do |assoc|
+        print_association_count(sample, assoc)
+      end
+      
+      puts pastel.dim("─" * 60)
+      nil
+    end
+
+    def print_association_count(sample, assoc)
+      count = sample.send(assoc.name).count
+      count_str = count == 0 ? pastel.red(count.to_s) : pastel.green(count.to_s)
+      puts "  #{pastel.blue(assoc.name.to_s.ljust(25))} → #{count_str} records"
+    rescue => e
+      puts "  #{pastel.blue(assoc.name.to_s.ljust(25))} → #{pastel.dim('error loading')}"
+    end
+  end
+end

data/lib/rails_console_pro/base_printer.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module RailsConsolePro
+  # Base printer class with common functionality
+  class BasePrinter
+    include ColorHelper
+
+    attr_reader :output, :value, :pry_instance
+
+    def initialize(output, value, pry_instance)
+      @output = output
+      @value = value
+      @pry_instance = pry_instance
+    end
+
+    def print
+      Pry::ColorPrinter.default(output, value, pry_instance)
+    end
+
+    protected
+
+    # Border helper with caching
+    BORDER_CACHE = {}
+    private_constant :BORDER_CACHE
+
+    def border(char = nil, length = nil)
+      char ||= config.border_char
+      length ||= config.header_width
+      cache_key = "#{char}#{length}"
+      BORDER_CACHE[cache_key] ||= color(config.get_color(:border), char * length)
+      output.puts BORDER_CACHE[cache_key]
+    end
+
+    def header(title, width = nil)
+      width ||= config.header_width
+      header_color = config.get_color(:header)
+      output.puts color(header_color, "┌─ #{title} " + "─" * (width - title.length - 4))
+    end
+
+    def footer(width = nil)
+      width ||= config.header_width
+      footer_color = config.get_color(:footer)
+      output.puts color(footer_color, "└" + "─" * width)
+    end
+
+    # Helper for bold colored text (delegates to ColorHelper)
+    def bold_color(method, text)
+      RailsConsolePro::ColorHelper.pastel.bold.public_send(method, text)
+    end
+
+    # Format value with type-aware coloring
+    def format_value(val)
+      case val
+      when NilClass
+        color(config.get_color(:attribute_value_nil), "nil")
+      when Numeric
+        color(config.get_color(:attribute_value_numeric), val.inspect)
+      when TrueClass, FalseClass
+        color(config.get_color(:attribute_value_boolean), val.inspect)
+      when Time, ActiveSupport::TimeWithZone
+        color(config.get_color(:attribute_value_time), val.to_s)
+      when String
+        color(config.get_color(:attribute_value_string), val.inspect)
+      else
+        color(config.get_color(:attribute_value_string), val.inspect)
+      end
+    end
+
+    # Get configuration instance
+    def config
+      RailsConsolePro.config
+    end
+  end
+end

data/lib/rails_console_pro/color_helper.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module RailsConsolePro
+  # Color helper module with memoization for performance
+  module ColorHelper
+    extend self
+
+    # Memoized pastel instance
+    def pastel
+      @pastel ||= PASTEL
+    end
+
+    # Delegates color methods to pastel with memoization
+    def color(method, text)
+      pastel.public_send(method, text)
+    end
+
+    # Helper for bold colored text
+    def bold_color(method, text)
+      pastel.bold.public_send(method, text)
+    end
+
+    # Chainable color methods
+    def method_missing(method_name, *args, &block)
+      if pastel.respond_to?(method_name)
+        pastel.public_send(method_name, *args, &block)
+      else
+        super
+      end
+    end
+
+    def respond_to_missing?(method_name, include_private = false)
+      pastel.respond_to?(method_name, include_private) || super
+    end
+  end
+end

data/lib/rails_console_pro/commands/base_command.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module RailsConsolePro
+  module Commands
+    # Base class for commands with shared functionality
+    class BaseCommand
+      include ColorHelper
+
+      protected
+
+      def pastel
+        ColorHelper.pastel
+      end
+    end
+  end
+end
+

data/lib/rails_console_pro/commands/diff_command.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+module RailsConsolePro
+  module Commands
+    class DiffCommand < BaseCommand
+      def execute(object1, object2)
+        return nil if object1.nil? || object2.nil?
+
+        execute_diff(object1, object2)
+      rescue => e
+        RailsConsolePro::ErrorHandler.handle(e, context: :diff)
+      end
+
+      private
+
+      def execute_diff(object1, object2)
+        differences = {}
+        identical = true
+
+        # Handle ActiveRecord objects
+        if object1.is_a?(ActiveRecord::Base) && object2.is_a?(ActiveRecord::Base)
+          differences, identical = diff_active_record_objects(object1, object2)
+        # Handle Hash objects
+        elsif object1.is_a?(Hash) && object2.is_a?(Hash)
+          differences, identical = diff_hashes(object1, object2)
+        # Handle plain objects with attributes
+        elsif object1.respond_to?(:attributes) && object2.respond_to?(:attributes)
+          differences, identical = diff_by_attributes(object1, object2)
+        else
+          # Simple comparison
+          identical = object1 == object2
+          differences = identical ? {} : { value: { old_value: object1, new_value: object2 } }
+        end
+
+        DiffResult.new(
+          object1: object1,
+          object2: object2,
+          differences: differences,
+          identical: identical
+        )
+      end
+
+      def diff_active_record_objects(object1, object2)
+        differences = {}
+        identical = true
+
+        # Get all attributes (including virtual ones)
+        all_attrs = (object1.attributes.keys | object2.attributes.keys).uniq
+
+        all_attrs.each do |attr|
+          val1 = object1.read_attribute(attr)
+          val2 = object2.read_attribute(attr)
+
+          if val1 != val2
+            identical = false
+            differences[attr] = {
+              old_value: val1,
+              new_value: val2
+            }
+          end
+        end
+
+        [differences, identical]
+      end
+
+      def diff_hashes(hash1, hash2)
+        differences = {}
+        identical = true
+
+        all_keys = (hash1.keys | hash2.keys).uniq
+
+        all_keys.each do |key|
+          val1 = hash1[key]
+          val2 = hash2[key]
+
+          if val1 != val2
+            identical = false
+            if hash1.key?(key) && hash2.key?(key)
+              differences[key] = {
+                old_value: val1,
+                new_value: val2
+              }
+            elsif hash1.key?(key)
+              differences[key] = {
+                only_in_object1: val1
+              }
+            else
+              differences[key] = {
+                only_in_object2: val2
+              }
+            end
+          end
+        end
+
+        [differences, identical]
+      end
+
+      def diff_by_attributes(object1, object2)
+        differences = {}
+        identical = true
+
+        attrs1 = object1.attributes rescue object1.instance_variables.map { |v| v.to_s.delete('@').to_sym }
+        attrs2 = object2.attributes rescue object2.instance_variables.map { |v| v.to_s.delete('@').to_sym }
+
+        all_attrs = (attrs1 | attrs2).uniq
+
+        all_attrs.each do |attr|
+          val1 = object1.respond_to?(attr) ? object1.public_send(attr) : nil
+          val2 = object2.respond_to?(attr) ? object2.public_send(attr) : nil
+
+          if val1 != val2
+            identical = false
+            if attrs1.include?(attr) && attrs2.include?(attr)
+              differences[attr] = {
+                old_value: val1,
+                new_value: val2
+              }
+            elsif attrs1.include?(attr)
+              differences[attr] = {
+                only_in_object1: val1
+              }
+            else
+              differences[attr] = {
+                only_in_object2: val2
+              }
+            end
+          end
+        end
+
+        [differences, identical]
+      end
+    end
+  end
+end
+