rails_console_pro 0.1.0

data/lib/rails_console_pro/pry_commands.rb

@@ -0,0 +1,241 @@
+# frozen_string_literal: true
+
+# Pry command definitions
+if defined?(Pry)
+  Pry::Commands.create_command "schema" do
+    description "Inspect database schema for a model"
+    
+    def process
+      pastel = RailsConsolePro::ColorHelper.pastel
+      unless RailsConsolePro.config.schema_command_enabled
+        output.puts pastel.yellow("Schema command is disabled. Enable it with: RailsConsolePro.configure { |c| c.schema_command_enabled = true }")
+        return
+      end
+
+      model_name = args.first
+      if model_name.nil?
+        output.puts pastel.red("Usage: schema ModelName")
+        output.puts pastel.yellow("Example: schema User")
+        return
+      end
+      
+      begin
+        model_class = model_name.constantize
+        result = RailsConsolePro::Commands.schema(model_class)
+        RailsConsolePro.call(output, result, pry_instance) if result
+      rescue NameError => e
+        output.puts pastel.red("Error: Could not find model '#{model_name}'")
+        output.puts pastel.yellow("Make sure the model name is correct and loaded.")
+      rescue => e
+        output.puts pastel.red("Error: #{e.message}")
+      end
+    end
+  end
+
+  Pry::Commands.create_command "explain" do
+    description "Analyze SQL query execution plan"
+    
+    def process
+      pastel = RailsConsolePro::ColorHelper.pastel
+      unless RailsConsolePro.config.explain_command_enabled
+        output.puts pastel.yellow("Explain command is disabled. Enable it with: RailsConsolePro.configure { |c| c.explain_command_enabled = true }")
+        return
+      end
+
+      if args.empty?
+        output.puts pastel.red("Usage: explain Model.where(...) or explain(Model, conditions)")
+        return
+      end
+      
+      begin
+        relation = eval(args.join(' '), target)
+        result = RailsConsolePro::Commands.explain(relation)
+        output.puts result if result
+      rescue => e
+        output.puts pastel.red("Error: #{e.message}")
+        output.puts pastel.yellow("💡 Use: explain(Model.where(...)) or explain(Model, key: value)")
+      end
+    end
+  end
+
+  Pry::Commands.create_command "navigate" do
+    description "Navigate through model associations interactively"
+    
+    def process
+      pastel = RailsConsolePro::ColorHelper.pastel
+      unless RailsConsolePro.config.navigate_command_enabled
+        output.puts pastel.yellow("Navigate command is disabled. Enable it with: RailsConsolePro.configure { |c| c.navigate_command_enabled = true }")
+        return
+      end
+
+      model_name = args.first
+      if model_name.nil?
+        output.puts pastel.red("Usage: navigate ModelName")
+        output.puts pastel.yellow("Example: navigate User")
+        return
+      end
+      
+      begin
+        model = model_name.constantize
+        navigator = RailsConsolePro::AssociationNavigator.new(model)
+        navigator.start
+      rescue ArgumentError => e
+        output.puts pastel.red("Error: #{e.message}")
+      end
+    end
+  end
+
+  Pry::Commands.create_command "export" do
+    description "Export data to JSON, YAML, or HTML file"
+    
+    def process
+      pastel = RailsConsolePro::ColorHelper.pastel
+      unless RailsConsolePro.config.export_enabled
+        output.puts pastel.yellow("Export command is disabled. Enable it with: RailsConsolePro.configure { |c| c.export_enabled = true }")
+        return
+      end
+
+      if args.empty?
+        show_usage
+        return
+      end
+      
+      begin
+        if args.size < 2
+          show_usage
+          return
+        end
+        
+        # Simple parsing: export <data> <file_path> [format]
+        file_path = args[-1].gsub(/^['"]|['"]$/, '')
+        data_expr = args[0..-2].join(' ')
+        
+        format_keywords = %w[json yaml yml html htm]
+        if args.size >= 3 && format_keywords.include?(args[-2].downcase)
+          format = args[-2].downcase
+          data_expr = args[0..-3].join(' ')
+        else
+          format = nil
+        end
+        
+        data = eval(data_expr, target)
+        result = RailsConsolePro::Commands.export(data, file_path, format: format)
+        
+        if result
+          output.puts pastel.green("✅ Exported to: #{File.expand_path(result)}")
+        else
+          output.puts pastel.red("❌ Export failed")
+        end
+      rescue SyntaxError => e
+        output.puts pastel.red("Syntax Error: #{e.message}")
+        show_usage
+      rescue => e
+        output.puts pastel.red("Error: #{e.message}")
+        output.puts pastel.yellow("💡 Tip: Make sure the data is exportable (schema result, explain result, ActiveRecord object, etc.)")
+        show_usage
+      end
+    end
+    
+    private
+    
+    def show_usage
+      pastel = RailsConsolePro::ColorHelper.pastel
+      output.puts pastel.red("Usage: export <data> <file_path> [format]")
+      output.puts pastel.yellow("")
+      output.puts pastel.yellow("Examples:")
+      output.puts pastel.cyan("  export schema(User) user_schema.json")
+      output.puts pastel.cyan("  export User.first user.html html")
+      output.puts pastel.cyan("  export explain(User.where(active: true)) query.json")
+      output.puts pastel.cyan("  export User.all users.json")
+      output.puts pastel.yellow("")
+      output.puts pastel.yellow("Formats: json, yaml, html (auto-detected from file extension if not specified)")
+      output.puts pastel.yellow("")
+      output.puts pastel.dim("💡 Tip: You can also use methods directly:")
+      output.puts pastel.dim("     schema(User).export_to_file('user.json')")
+      output.puts pastel.dim("     User.first.export_to_file('user.html', format: 'html')")
+    end
+  end
+
+  Pry::Commands.create_command "stats" do
+    description "Show model statistics (record count, growth rate, table size, index usage)"
+    
+    def process
+      pastel = RailsConsolePro::ColorHelper.pastel
+      unless RailsConsolePro.config.stats_command_enabled
+        output.puts pastel.yellow("Stats command is disabled. Enable it with: RailsConsolePro.configure { |c| c.stats_command_enabled = true }")
+        return
+      end
+
+      model_name = args.first
+      if model_name.nil?
+        output.puts pastel.red("Usage: stats ModelName")
+        output.puts pastel.yellow("Example: stats User")
+        return
+      end
+      
+      begin
+        model_class = model_name.constantize
+        result = RailsConsolePro::Commands.stats(model_class)
+        RailsConsolePro.call(output, result, pry_instance) if result
+      rescue NameError => e
+        output.puts pastel.red("Error: Could not find model '#{model_name}'")
+        output.puts pastel.yellow("Make sure the model name is correct and loaded.")
+      rescue => e
+        output.puts pastel.red("Error: #{e.message}")
+      end
+    end
+  end
+
+  Pry::Commands.create_command "diff" do
+    description "Compare two objects and highlight differences"
+    
+    def process
+      pastel = RailsConsolePro::ColorHelper.pastel
+      unless RailsConsolePro.config.diff_command_enabled
+        output.puts pastel.yellow("Diff command is disabled. Enable it with: RailsConsolePro.configure { |c| c.diff_command_enabled = true }")
+        return
+      end
+
+      if args.empty?
+        output.puts pastel.red("Usage: diff object1, object2")
+        output.puts pastel.yellow("Examples:")
+        output.puts pastel.cyan("  diff User.first, User.last")
+        output.puts pastel.cyan("  diff user1, user2")
+        output.puts pastel.cyan("  diff {a: 1}, {a: 2}")
+        return
+      end
+      
+      begin
+        all_args = args.join(' ')
+        parts = all_args.split(',').map(&:strip)
+        
+        if parts.size < 2
+          output.puts pastel.red("Error: Need two objects to compare (separated by comma)")
+          output.puts pastel.yellow("Usage: diff object1, object2")
+          return
+        end
+        
+        object1 = eval(parts[0], target)
+        object2 = eval(parts[1], target)
+        
+        result = RailsConsolePro::Commands.diff(object1, object2)
+        RailsConsolePro.call(output, result, pry_instance) if result
+      rescue SyntaxError => e
+        output.puts pastel.red("Syntax Error: #{e.message}")
+        output.puts pastel.yellow("💡 Make sure to separate objects with a comma: diff object1, object2")
+      rescue => e
+        output.puts pastel.red("Error: #{e.message}")
+        output.puts pastel.yellow("💡 Use: diff object1, object2")
+      end
+    end
+  end
+
+  # Add aliases
+  begin
+    Pry.commands.alias_command 'nav', 'navigate'
+    Pry.commands.alias_command 'n', 'navigate'
+  rescue => e
+    # Silently fail if aliases can't be registered
+  end
+end
+

data/lib/rails_console_pro/pry_integration.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+# Pry integration - sets up Pry hooks
+if defined?(Pry)
+  Pry.config.print = proc do |output, value, pry_instance|
+    RailsConsolePro.call(output, value, pry_instance)
+  end
+end
+

data/lib/rails_console_pro/railtie.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module RailsConsolePro
+  # Rails integration via Railtie
+  class Railtie < Rails::Railtie
+    # Auto-load Rails Console Pro when Rails starts
+    # The initializer.rb file handles the actual setup
+    config.after_initialize do
+      # Ensure Pry hook is set (in case Pry loads after the gem)
+      if defined?(Pry)
+        # Wrap in a proc that handles errors gracefully
+        Pry.config.print = proc do |output, value, pry_instance|
+          begin
+            RailsConsolePro.call(output, value, pry_instance)
+          rescue => e
+            # Fallback to default Pry printing if our printer fails
+            if Rails.env.development? || ENV['RAILS_CONSOLE_PRO_DEBUG']
+              pastel = RailsConsolePro::ColorHelper.pastel
+              output.puts pastel.red.bold("💥 RailsConsolePro Error in Pry hook: #{e.class}: #{e.message}")
+              output.puts pastel.dim(e.backtrace.first(3).join("\n"))
+            end
+            Pry::ColorPrinter.default(output, value, pry_instance)
+          end
+        end
+        Rails.logger&.debug("Rails Console Pro: Pry integration active")
+      end
+    end
+  end
+end

data/lib/rails_console_pro/schema_inspector_result.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module RailsConsolePro
+  # Value object for schema inspection results
+  class SchemaInspectorResult
+    attr_reader :model
+
+    def initialize(model)
+      @model = model
+      validate_model!
+    end
+
+    def ==(other)
+      other.is_a?(self.class) && other.model == model
+    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: "Schema: #{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_for_schema!(model)
+    end
+  end
+end

data/lib/rails_console_pro/serializers/active_record_serializer.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module RailsConsolePro
+  module Serializers
+    class ActiveRecordSerializer < BaseSerializer
+      def serialize(record)
+        {
+          'type' => 'active_record',
+          'class' => record.class.name,
+          'id' => record.id,
+          'attributes' => record.attributes,
+          'errors' => record.errors.any? ? record.errors.full_messages : nil
+        }.compact
+      end
+    end
+  end
+end
+

data/lib/rails_console_pro/serializers/array_serializer.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module RailsConsolePro
+  module Serializers
+    class ArraySerializer < BaseSerializer
+      def serialize(array)
+        if array.all? { |item| item.is_a?(ActiveRecord::Base) }
+          {
+            'type' => 'active_record_collection',
+            'model' => array.first.class.name,
+            'count' => array.size,
+            'records' => array.map { |r| serialize_active_record(r) }
+          }
+        else
+          {
+            'type' => 'array',
+            'count' => array.size,
+            'items' => array.map { |item| serialize_data(item) }
+          }
+        end
+      end
+
+      private
+
+      def serialize_active_record(record)
+        ActiveRecordSerializer.serialize(record, exporter)
+      end
+    end
+  end
+end
+

data/lib/rails_console_pro/serializers/base_serializer.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module RailsConsolePro
+  module Serializers
+    # Base serializer class
+    class BaseSerializer
+      def self.serialize(data, exporter)
+        new(exporter).serialize(data)
+      end
+
+      def initialize(exporter)
+        @exporter = exporter
+      end
+
+      protected
+
+      attr_reader :exporter
+
+      def serialize_data(data)
+        exporter.send(:serialize_data, data)
+      end
+    end
+  end
+end
+

data/lib/rails_console_pro/serializers/diff_serializer.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module RailsConsolePro
+  module Serializers
+    class DiffSerializer < BaseSerializer
+      def serialize(result)
+        {
+          'type' => 'diff_comparison',
+          'object1_type' => result.object1_type,
+          'object2_type' => result.object2_type,
+          'identical' => result.identical,
+          'different_types' => result.different_types?,
+          'diff_count' => result.diff_count,
+          'has_differences' => result.has_differences?,
+          'differences' => serialize_data(result.differences),
+          'object1' => serialize_data(result.object1),
+          'object2' => serialize_data(result.object2),
+          'timestamp' => result.timestamp.iso8601
+        }
+      end
+    end
+  end
+end
+

data/lib/rails_console_pro/serializers/explain_serializer.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module RailsConsolePro
+  module Serializers
+    class ExplainSerializer < BaseSerializer
+      def serialize(result)
+        {
+          'type' => 'sql_explain',
+          'sql' => result.sql,
+          'execution_time' => result.execution_time,
+          'explain_output' => format_explain_output(result.explain_output),
+          'indexes_used' => result.indexes_used,
+          'recommendations' => result.recommendations,
+          'statistics' => result.statistics,
+          'slow_query' => result.slow_query?,
+          'has_indexes' => result.has_indexes?
+        }
+      end
+
+      private
+
+      def format_explain_output(explain_output)
+        case explain_output
+        when String
+          explain_output
+        when Array
+          explain_output.map { |row| row.is_a?(Hash) ? row : row.to_s }
+        else
+          explain_output.inspect
+        end
+      end
+    end
+  end
+end
+

data/lib/rails_console_pro/serializers/relation_serializer.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module RailsConsolePro
+  module Serializers
+    class RelationSerializer < BaseSerializer
+      def serialize(relation)
+        records = relation.to_a
+        {
+          'type' => 'active_record_relation',
+          'model' => relation.klass.name,
+          'count' => records.size,
+          'records' => records.map { |r| serialize_active_record(r) },
+          'sql' => relation.to_sql
+        }
+      end
+
+      private
+
+      def serialize_active_record(record)
+        ActiveRecordSerializer.serialize(record, exporter)
+      end
+    end
+  end
+end
+

data/lib/rails_console_pro/serializers/schema_serializer.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+module RailsConsolePro
+  module Serializers
+    class SchemaSerializer < BaseSerializer
+      def serialize(result)
+        model = result.model
+        {
+          'type' => 'schema_inspection',
+          'model' => model.name,
+          'table_name' => model.table_name,
+          'columns' => serialize_columns(model),
+          'indexes' => serialize_indexes(model),
+          'associations' => serialize_associations(model),
+          'validations' => serialize_validations(model),
+          'scopes' => serialize_scopes(model),
+          'database' => serialize_database_info(model)
+        }
+      end
+
+      private
+
+      def serialize_columns(model)
+        model.columns.map do |column|
+          {
+            'name' => column.name.to_s,
+            'type' => column.type.to_s,
+            'null' => column.null,
+            'default' => column.default,
+            'limit' => column.limit,
+            'precision' => column.precision,
+            'scale' => column.scale
+          }.compact
+        end
+      end
+
+      def serialize_indexes(model)
+        model.connection.indexes(model.table_name).map do |index|
+          where_clause = if index.where.is_a?(Regexp)
+                           index.where.to_s
+                         else
+                           index.where
+                         end
+          {
+            'name' => index.name.to_s,
+            'columns' => index.columns.map(&:to_s),
+            'unique' => index.unique,
+            'where' => where_clause
+          }.compact
+        end
+      end
+
+      def serialize_associations(model)
+        associations = {}
+        %i[belongs_to has_one has_many has_and_belongs_to_many].each do |macro|
+          assocs = model.reflect_on_all_associations(macro)
+          next if assocs.empty?
+
+          associations[macro.to_s] = assocs.map do |assoc|
+            {
+              'name' => assoc.name.to_s,
+              'class_name' => assoc.class_name,
+              'foreign_key' => assoc.respond_to?(:foreign_key) ? assoc.foreign_key : nil,
+              'dependent' => assoc.options[:dependent]&.to_s,
+              'optional' => assoc.options[:optional],
+              'through' => assoc.options[:through]&.to_s,
+              'join_table' => assoc.respond_to?(:join_table) ? assoc.join_table : nil
+            }.compact
+          end
+        end
+        associations
+      end
+
+      def serialize_validations(model)
+        validators_by_attr = model.validators.each_with_object({}) do |validator, hash|
+          validator.attributes.each do |attr|
+            attr_key = attr.is_a?(Symbol) ? attr.to_s : attr
+            (hash[attr_key] ||= []) << {
+              type: validator.class.name.split('::').last.gsub('Validator', ''),
+              options: serialize_options(validator.options)
+            }
+          end
+        end
+        validators_by_attr
+      end
+
+      def serialize_options(options)
+        return nil if options.nil?
+        return options if options.empty?
+        
+        options.each_with_object({}) do |(key, value), result|
+          string_key = key.is_a?(Symbol) ? key.to_s : key
+          result[string_key] = case value
+          when Symbol
+            value.to_s
+          when Regexp
+            value.to_s
+          when Array
+            value.map { |v| v.is_a?(Symbol) || v.is_a?(Regexp) ? v.to_s : serialize_data(v) }
+          else
+            serialize_data(value)
+          end
+        end
+      end
+
+      def serialize_scopes(model)
+        return [] unless model.respond_to?(:scopes) && model.scopes.any?
+        model.scopes.keys.map(&:to_s)
+      end
+
+      def serialize_database_info(model)
+        connection = model.connection
+        {
+          adapter: connection.adapter_name,
+          database: connection.respond_to?(:current_database) ? connection.current_database : nil
+        }.compact
+      end
+    end
+  end
+end
+

data/lib/rails_console_pro/serializers/stats_serializer.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module RailsConsolePro
+  module Serializers
+    class StatsSerializer < BaseSerializer
+      def serialize(result)
+        {
+          'type' => 'statistics',
+          'model' => result.model.name,
+          'record_count' => result.record_count,
+          'growth_rate' => result.growth_rate,
+          'table_size' => result.table_size,
+          'index_usage' => serialize_data(result.index_usage),
+          'column_stats' => serialize_data(result.column_stats),
+          'timestamp' => result.timestamp.iso8601,
+          'has_growth_data' => result.has_growth_data?,
+          'has_table_size' => result.has_table_size?,
+          'has_index_data' => result.has_index_data?
+        }
+      end
+    end
+  end
+end
+