rails_console_pro 0.1.2 → 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/jobs_command.rb

@@ -0,0 +1,212 @@
+# frozen_string_literal: true
+
+module RailsConsolePro
+  module Commands
+    class JobsCommand < BaseCommand
+      DEFAULT_LIMIT = 20
+
+      def execute(options = nil)
+        unless feature_enabled?
+          puts pastel.yellow("Jobs command is disabled. Enable it with: RailsConsolePro.configure { |c| c.queue_command_enabled = true }")
+          return nil
+        end
+
+        unless active_job_available?
+          puts pastel.red("ActiveJob is not loaded. Queue insights require ActiveJob to be available.")
+          return nil
+        end
+
+        normalized_options = normalize_options(options)
+
+        fetch_options, filter_options, action_options = split_options(normalized_options)
+        action_results = perform_actions(action_options, fetch_options)
+        action_results.each { |result| print_action_result(result) }
+
+        result = fetcher.fetch(**fetch_options)
+        return result unless result
+
+        apply_filters(result, filter_options)
+      rescue => e
+        RailsConsolePro::ErrorHandler.handle(e, context: :jobs)
+      end
+
+      private
+
+      def feature_enabled?
+        RailsConsolePro.config.queue_command_enabled
+      end
+
+      def active_job_available?
+        defined?(ActiveJob::Base)
+      end
+
+      def fetcher
+        @fetcher ||= Services::QueueInsightFetcher.new
+      end
+
+      def action_service
+        @action_service ||= Services::QueueActionService.new
+      end
+
+      def perform_actions(action_options, fetch_options)
+        return [] if action_options.empty?
+
+        action_options.each_with_object([]) do |(action_key, value), results|
+          next if value.nil? || (value.respond_to?(:empty?) && value.empty?)
+
+          result = action_service.perform(
+            action: action_key,
+            jid: value,
+            queue: fetch_options[:queue]
+          )
+          results << result if result
+        end
+      end
+
+      def apply_filters(result, filter_options)
+        filters = prepare_filters(filter_options)
+        filtered_enqueued = result.enqueued_jobs
+        filtered_retry = result.retry_jobs
+        filtered_recent = result.recent_executions
+        additional_warnings = []
+
+        statuses = filters[:statuses]
+        unless statuses.empty?
+          show_enqueued = statuses.include?(:enqueued) || statuses.include?(:scheduled) || statuses.include?(:all)
+          show_retry = statuses.include?(:retry) || statuses.include?(:retries) || statuses.include?(:all)
+          show_recent = statuses.include?(:recent) || statuses.include?(:executing) || statuses.include?(:running) || statuses.include?(:all)
+
+          filtered_enqueued = [] unless show_enqueued
+          filtered_retry = [] unless show_retry
+          filtered_recent = [] unless show_recent
+        end
+
+        if filters[:job_class]
+          matcher = filters[:job_class]
+          filtered_enqueued = filtered_enqueued.select { |job| job_class_matches?(job, matcher) }
+          filtered_retry = filtered_retry.select { |job| job_class_matches?(job, matcher) }
+          filtered_recent = filtered_recent.select { |job| job_class_matches?(job, matcher) }
+          if filtered_enqueued.empty? && filtered_retry.empty? && filtered_recent.empty?
+            additional_warnings << "No jobs matching class filter '#{matcher}'."
+          end
+        end
+
+        filtered_result = result.with_overrides(
+          enqueued_jobs: filtered_enqueued,
+          retry_jobs: filtered_retry,
+          recent_executions: filtered_recent,
+          warnings: result.warnings + additional_warnings
+        )
+
+        filtered_result
+      end
+
+      def normalize_options(options)
+        case options
+        when Numeric
+          { limit: options.to_i }
+        when Hash
+          symbolized = options.each_with_object({}) do |(key, value), acc|
+            sym_key = key.to_sym
+            sym_key = :job_class if sym_key == :class
+            acc[sym_key] = value
+          end
+          symbolized
+        when nil
+          {}
+        else
+          {}
+        end.then do |opts|
+          limit = opts.fetch(:limit, DEFAULT_LIMIT)
+          limit = limit.to_i
+          limit = DEFAULT_LIMIT if limit <= 0
+          opts[:limit] = limit
+          opts[:job_class] = opts[:job_class].to_s.strip if opts.key?(:job_class) && opts[:job_class]
+          [:retry, :delete, :details].each do |key|
+            opts[key] = opts[key].to_s.strip if opts.key?(key) && opts[key]
+          end
+          opts
+        end
+      end
+
+      def split_options(options)
+        fetch_options = {
+          limit: options[:limit],
+          queue: options[:queue]
+        }.compact
+
+        filter_options = {
+          statuses: options[:statuses] || options[:status],
+          job_class: options[:job_class]
+        }.compact
+
+        action_options = {
+          retry: options[:retry],
+          delete: options[:delete],
+          details: options[:details]
+        }.compact
+
+        [fetch_options, filter_options, action_options]
+      end
+
+      def prepare_filters(filter_options)
+        statuses =
+          Array(filter_options[:statuses]).flat_map { |s| s.to_s.split(',') }
+                                             .map(&:strip)
+                                             .reject(&:empty?)
+                                             .map { |s| s.downcase.to_sym }
+                                             .uniq
+
+        {
+          statuses: statuses,
+          job_class: filter_options[:job_class],
+          limit: filter_options[:limit]
+        }
+      end
+
+      def job_class_matches?(job, matcher)
+        job_class = job.job_class.to_s
+        return false if job_class.empty?
+
+        matcher_str = matcher.to_s
+        job_class.casecmp?(matcher_str) ||
+          job_class.split('::').last.casecmp?(matcher_str) ||
+          job_class.include?(matcher_str)
+      end
+
+      def print_action_result(result)
+        return unless result
+
+        if result.warning
+          puts pastel.yellow("⚠️  #{result.warning}")
+        end
+
+        if result.message
+          color_method = result.success ? :green : :cyan
+          puts pastel.public_send(color_method, result.message)
+        end
+
+        if result.details
+          puts pastel.cyan("Details:")
+          formatted = format_details(result.details)
+          puts formatted
+        end
+      end
+
+      def format_details(details)
+        case details
+        when String
+          "  #{details}"
+        when Hash
+          details.map { |key, value| "  #{key}: #{value.inspect}" }.join("\n")
+        when Array
+          details.map { |value| "  - #{value.inspect}" }.join("\n")
+        else
+          details.inspect
+        end
+      end
+    end
+  end
+end
+
+

data/lib/rails_console_pro/commands/profile_command.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module RailsConsolePro
+  module Commands
+    # Command for profiling arbitrary blocks, callables, or ActiveRecord relations
+    class ProfileCommand < BaseCommand
+      def execute(target = nil, *args, label: nil, &block)
+        return disabled_message unless enabled?
+
+        label, target, block = normalize_arguments(label, target, block)
+        execution = build_execution(target, args, block)
+        return execution if execution.nil? || execution.is_a?(String)
+
+        collector = Services::ProfileCollector.new(config)
+        collector.profile(label: label || execution[:label]) do
+          execution[:callable].call
+        end
+      rescue => e
+        RailsConsolePro::ErrorHandler.handle(e, context: :profile)
+      end
+
+      private
+
+      def enabled?
+        RailsConsolePro.config.enabled && RailsConsolePro.config.profile_command_enabled
+      end
+
+      def disabled_message
+        pastel.yellow('Profile command is disabled. Enable it via RailsConsolePro.configure { |c| c.profile_command_enabled = true }')
+      end
+
+      def config
+        RailsConsolePro.config
+      end
+
+      def normalize_arguments(label, target, block)
+        if block_provided?(block) && (target.is_a?(String) || target.is_a?(Symbol))
+          label ||= target.to_s
+          target = nil
+        end
+        [label, target, block]
+      end
+
+      def block_provided?(block)
+        !block.nil?
+      end
+
+      def build_execution(target, args, block)
+        if block_provided?(block)
+          { callable: block, label: nil }
+        elsif relation?(target)
+          relation = target
+          { callable: -> { relation.load }, label: "#{relation.klass.name} relation" }
+        elsif callable?(target)
+          callable = target
+          { callable: -> { callable.call(*args) }, label: callable_label(callable) }
+        elsif target.nil?
+          pastel.red('Nothing to profile. Provide a block, callable, or ActiveRecord relation.')
+        else
+          { callable: -> { target }, label: target.class.name }
+        end
+      end
+
+      def relation?(object)
+        defined?(ActiveRecord::Relation) && object.is_a?(ActiveRecord::Relation)
+      end
+
+      def callable?(object)
+        object.respond_to?(:call)
+      end
+
+      def callable_label(callable)
+        if callable.respond_to?(:name) && callable.name
+          callable.name
+        elsif callable.respond_to?(:receiver) && callable.respond_to?(:name)
+          "#{callable.receiver.class}##{callable.name}"
+        else
+          callable.class.name
+        end
+      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/snippets_command.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+module RailsConsolePro
+  module Commands
+    # Command for managing, searching, and listing reusable console snippets
+    class SnippetsCommand < BaseCommand
+      DEFAULT_LIST_LIMIT = 10
+
+      def execute(action = :list, *args, **kwargs, &block)
+        return disabled_message unless enabled?
+
+        action = infer_action(action, args)
+        case action
+        when :list
+          list_snippets(**kwargs)
+        when :search
+          search_snippets(*args, **kwargs)
+        when :add, :create
+          add_snippet(*args, **kwargs, &block)
+        when :show
+          show_snippet(*args)
+        when :delete, :remove
+          delete_snippet(*args)
+        when :favorite
+          toggle_favorite(*args, value: true)
+        when :unfavorite
+          toggle_favorite(*args, value: false)
+        else
+          pastel.red("Unknown snippets action: #{action}")
+        end
+      rescue ArgumentError => e
+        pastel.red("Snippets error: #{e.message}")
+      end
+
+      private
+
+      def enabled?
+        RailsConsolePro.config.enabled && RailsConsolePro.config.snippets_command_enabled
+      end
+
+      def disabled_message
+        pastel.yellow('Snippets command is disabled. Enable via RailsConsolePro.configure { |c| c.snippets_command_enabled = true }')
+      end
+
+      def infer_action(action, args)
+        return action.to_sym if action.respond_to?(:to_sym)
+        return :search if args.any?
+
+        :list
+      end
+
+      def list_snippets(limit: DEFAULT_LIST_LIMIT, favorites: false)
+        snippets = repository.all(limit: limit)
+        snippets = snippets.select(&:favorite?) if favorites
+
+        Snippets::CollectionResult.new(
+          snippets: snippets,
+          limit: limit,
+          total_count: repository.all.size,
+          tags: favorites ? ['favorite'] : []
+        )
+      end
+
+      def search_snippets(term = nil, tags: nil, limit: DEFAULT_LIST_LIMIT)
+        search_result = repository.search(term: term, tags: tags, limit: limit)
+        snippets = search_result[:results]
+        Snippets::CollectionResult.new(
+          snippets: snippets,
+          query: term,
+          tags: Array(tags),
+          limit: limit,
+          total_count: search_result[:total_count]
+        )
+      end
+
+      def add_snippet(body = nil, id: nil, tags: nil, description: nil, favorite: false, metadata: nil, &block)
+        snippet_body = extract_body(body, &block)
+
+        snippet = repository.add(
+          body: snippet_body,
+          id: id,
+          tags: tags,
+          description: description,
+          favorite: favorite,
+          metadata: metadata
+        )
+
+        Snippets::SingleResult.new(snippet: snippet, action: :add, created: true)
+      end
+
+      def show_snippet(id)
+        snippet = repository.find(id)
+        return pastel.yellow("No snippet found for '#{id}'") unless snippet
+
+        Snippets::SingleResult.new(snippet: snippet, action: :show, created: false)
+      end
+
+      def delete_snippet(id)
+        if repository.delete(id)
+          pastel.green("Removed snippet '#{id}'")
+        else
+          pastel.yellow("No snippet found for '#{id}'")
+        end
+      end
+
+      def toggle_favorite(id, value:)
+        snippet = repository.update(id, favorite: value)
+        return pastel.yellow("No snippet found for '#{id}'") unless snippet
+
+        status = value ? 'marked as favorite' : 'removed from favorites'
+        message = pastel.green("Snippet '#{id}' #{status}.")
+        Snippets::SingleResult.new(
+          snippet: snippet,
+          action: value ? :favorite : :unfavorite,
+          created: false,
+          message: message
+        )
+      end
+
+      def extract_body(body, &block)
+        content = if block
+                    result = block.call
+                    result.respond_to?(:join) ? result.join("\n") : result.to_s
+                  else
+                    body
+                  end
+
+        raise ArgumentError, 'Snippet body is required' if content.nil? || content.to_s.strip.empty?
+
+        content.to_s
+      end
+
+      def repository
+        @repository ||= RailsConsolePro::Services::SnippetRepository.new(
+          store_path: RailsConsolePro.config.snippet_store_path
+        )
+      end
+    end
+  end
+end
+