console_kit 1.1.0 → 1.3.0

data/lib/console_kit/output.rb

@@ -34,7 +34,7 @@ module ConsoleKit
           return if silent
 
           formatted = (type == :header ? "\n--- #{text} ---" : text)
-          print_with(type, formatted, timestamp, { newline: newline })
+          print_with(type, formatted, timestamp: timestamp, newline: newline)
         end
       end
 
@@ -51,19 +51,33 @@ module ConsoleKit
         puts text
       end
 
-      # Backtrace prints always with timestamp, no param
       def print_backtrace(exception)
         return if silent
 
-        exception&.backtrace&.each { |line| print_with(:trace, "    #{line}", true, { newline: true }) }
+        exception&.backtrace&.each do |line|
+          print_with(:trace, "    #{line}", timestamp: true)
+        end
       end
 
       private
 
-      def print_with(type, text, timestamp, opts = {})
+      def print_with(type, text, options = {})
+        opts = options.is_a?(Hash) ? options : { timestamp: options }
+        message = build_formatted_message(type, text, opts[:timestamp])
+
+        opts.fetch(:newline, true) ? puts(message) : print(message)
+      end
+
+      def build_formatted_message(type, text, timestamp)
         meta = TYPES.fetch(type)
         message = build_message(text, meta[:symbol], timestamp)
-        emit(message, meta[:color], opts.fetch(:newline, true))
+        colorize(message, meta[:color])
+      end
+
+      def colorize(message, color)
+        return message unless ConsoleKit.configuration.pretty_output && color
+
+        "\e[#{color}m#{message}\e[0m"
       end
 
       def build_message(text, symbol, timestamp)
@@ -73,12 +87,6 @@ module ConsoleKit
       def prefix_for(value) = value ? yield(value) : ''
       def timestamp_prefix(timestamp) = prefix_for(timestamp) { Time.current.strftime('[%Y-%m-%d %H:%M:%S] ') }
       def symbol_prefix(symbol) = prefix_for(symbol) { |sym| "#{sym} " }
-
-      def emit(message, color, newline)
-        writer = newline ? :puts : :print
-        formatted = ConsoleKit.configuration.pretty_output && color ? "\e[#{color}m#{message}\e[0m" : message
-        send(writer, formatted)
-      end
     end
   end
 end

data/lib/console_kit/prompt.rb

@@ -18,8 +18,8 @@ module ConsoleKit
 
       def apply_irb_prompt
         conf = IRB.conf
-        conf[:PROMPT] ||= {}
-        conf[:PROMPT][:CONSOLE_KIT] = {
+        prompt = conf[:PROMPT] ||= {}
+        prompt[:CONSOLE_KIT] = {
           PROMPT_I: "#{tenant_label} %N(%m):%03n> ",
           PROMPT_S: "#{tenant_label} %N(%m):%03n%l ",
           PROMPT_C: "#{tenant_label} %N(%m):%03n* ",
@@ -29,14 +29,21 @@ module ConsoleKit
       end
 
       def apply_pry_prompt
-        Pry.config.prompt = Pry::Prompt.new(
-          'console_kit',
-          'ConsoleKit tenant prompt',
-          [
-            proc { |obj, nest_level, _pry_instance| "#{Prompt.send(:tenant_label)} (#{obj}):#{nest_level}> " },
-            proc { |obj, nest_level, _pry_instance| "#{Prompt.send(:tenant_label)} (#{obj}):#{nest_level}* " }
-          ]
-        )
+        procs = pry_prompt_procs(tenant_label)
+        Pry.config.prompt = build_pry_prompt(procs)
+      end
+
+      def pry_prompt_procs(label)
+        [
+          proc { |obj, nest, _| "#{label} (#{obj}):#{nest}> " },
+          proc { |obj, nest, _| "#{label} (#{obj}):#{nest}* " }
+        ]
+      end
+
+      def build_pry_prompt(procs)
+        return procs unless defined?(Pry::Prompt)
+
+        Pry::Prompt.try(:new, 'console_kit', 'ConsoleKit tenant prompt', procs) || procs
       end
     end
   end

data/lib/console_kit/railtie.rb

@@ -6,10 +6,10 @@ module ConsoleKit
     console do
       ConsoleKit::Setup.setup
       ConsoleKit::Prompt.apply
-      if defined?(Pry)
-        TOPLEVEL_BINDING.receiver.extend(ConsoleKit::ConsoleHelpers)
-      elsif defined?(IRB::ExtendCommandBundle)
+      if defined?(IRB::ExtendCommandBundle) && !defined?(Pry)
         IRB::ExtendCommandBundle.include(ConsoleKit::ConsoleHelpers)
+      else
+        TOPLEVEL_BINDING.receiver.extend(ConsoleKit::ConsoleHelpers)
       end
     end
 

data/lib/console_kit/setup.rb

@@ -3,135 +3,25 @@
 require_relative 'tenant_selector'
 require_relative 'tenant_configurator'
 require_relative 'output'
+require_relative 'setup_ui'
+require_relative 'tenant_orchestrator'
 
 # Core Logic for initial Setup
 module ConsoleKit
   # Does the initial setup
   module Setup
     class << self
-      ENVIRONMENT_WARNINGS = {
-        'production' => -> { Output.print_error('WARNING: You are connected to a PRODUCTION environment!') },
-        'staging' => -> { Output.print_warning('You are connected to a staging environment.') }
-      }.freeze
-
       def current_tenant = Thread.current[:console_kit_current_tenant]
 
       def current_tenant=(val)
         Thread.current[:console_kit_current_tenant] = val
       end
 
-      def setup = run_setup
+      def setup = TenantOrchestrator.run
       def tenant_setup_successful? = !current_tenant.to_s.empty?
-
-      def reapply
-        return unless tenant_setup_successful?
-
-        Output.silence { TenantConfigurator.configure_tenant(current_tenant) }
-      end
-
-      def reset_current_tenant
-        return warn_no_tenants unless tenants?
-
-        key = select_tenant_key
-        return cancel_switch if key == :abort || key.blank?
-
-        clear_current_tenant
-        return skip_tenant_message if %i[exit none].include?(key)
-
-        configure(key)
-      end
-
-      private
-
-      def run_setup
-        return if tenant_setup_successful?
-
-        ConsoleKit.configuration.validate!
-        select_and_configure
-      rescue StandardError => e
-        handle_error(e)
-      end
-
-      def select_and_configure
-        key = select_tenant_key
-        return handle_selection_result(key) if %i[exit abort none].include?(key) || key.blank?
-
-        configure(key)
-      end
-
-      def handle_selection_result(key)
-        exit_on_key if %i[exit abort].include?(key)
-
-        case key
-        when :none
-          Output.print_info('No tenant selected. Loading without tenant configuration.')
-        when nil, ''
-          Output.print_error('Tenant selection failed. Loading without tenant configuration.')
-        end
-      end
-
-      def exit_on_key
-        Output.print_info('Exiting console...')
-        Kernel.exit
-      end
-
-      def configure(key)
-        TenantConfigurator.configure_tenant(key)
-        return unless TenantConfigurator.configuration_success
-
-        self.current_tenant = key
-        Prompt.apply
-        print_tenant_banner(key)
-      end
-
-      def print_tenant_banner(key)
-        constants = ConsoleKit.configuration.tenants[key]&.[](:constants) || {}
-        env = constants[:environment]&.to_s&.downcase
-        Output.print_success("Tenant initialized: #{key}")
-        print_environment_warning(env) if env
-        print_active_connections
-      end
-
-      def print_environment_warning(env) = ENVIRONMENT_WARNINGS[env]&.call
-
-      def print_active_connections
-        names = active_connection_names
-        Output.print_info("Active connections: #{names.join(', ')}") unless names.empty?
-      end
-
-      def active_connection_names
-        ctx = context_class
-        return [] unless ctx
-
-        handlers = ConsoleKit::Connections::ConnectionManager.available_handlers(ctx)
-        handlers.map { |h| h.class.name.demodulize.delete_suffix('ConnectionHandler') }
-      end
-
-      def tenants = ConsoleKit.configuration.tenants
-      def context_class = ConsoleKit.configuration.context_class
-      def tenants? = tenants&.any?
-      def no_tenants? = !tenants?
-      def select_tenant_key = auto_select? ? tenants.keys.first : TenantSelector.select
-      def auto_select? = single_tenant? || non_interactive?
-      def single_tenant? = tenants.size == 1
-      def non_interactive? = !$stdin.tty?
-      def warn_no_tenants = Output.print_warning('Cannot reset tenant: No tenants configured.')
-      def warn_reset = Output.print_warning("Resetting tenant: #{current_tenant}")
-      def cancel_switch = Output.print_warning('Tenant switch cancelled.')
-      def skip_tenant_message = Output.print_info('No tenant selected. Loading without tenant configuration.')
-
-      def clear_current_tenant
-        if current_tenant
-          warn_reset
-          TenantConfigurator.clear
-        end
-        self.current_tenant = nil
-      end
-
-      def handle_error(error)
-        Output.print_error("Error setting up tenant: #{error.message}")
-        Output.print_backtrace(error)
-      end
+      def reapply = TenantOrchestrator.reapply
+      def reset_current_tenant = TenantOrchestrator.reset
+      def auto_select? = TenantOrchestrator.auto_select?
     end
   end
 end

data/lib/console_kit/setup_ui.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module ConsoleKit
+  # UI helpers for Setup
+  module SetupUI
+    ENVIRONMENT_WARNINGS = {
+      'production' => -> { Output.print_error('!!! CAUTION: YOU ARE IN PRODUCTION ENVIRONMENT !!!') },
+      'staging' => -> { Output.print_warning('CAUTION: You are in staging environment.') }
+    }.freeze
+
+    class << self
+      def print_tenant_banner(key, config)
+        Output.print_success("Tenant initialized: #{key}")
+        print_env_warning(key, config)
+        print_active_connections
+        ConsoleKit::Connections::Dashboard.display if config.show_dashboard
+      end
+
+      private
+
+      def print_env_warning(key, config)
+        constants = config.tenants[key]&.[](:constants) || {}
+        env = constants[:environment]&.to_s&.downcase
+        ENVIRONMENT_WARNINGS[env]&.call if env
+      end
+
+      def print_active_connections
+        ctx = ConsoleKit.configuration.context_class
+        active = Connections::ConnectionManager.available_handlers(ctx).map do |handler|
+          handler.class.name.demodulize.delete_suffix('ConnectionHandler')
+        end
+
+        Output.print_info("Active connections: #{active.join(', ')}") if active.any?
+      end
+    end
+  end
+end

data/lib/console_kit/tenant_configurator/context_wrapper.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module ConsoleKit
+  module TenantConfigurator
+    # Encapsulates context and attributes to resolve DataClump smells
+    class ContextWrapper
+      HANDLER_ATTRIBUTES = {
+        Connections::SqlConnectionHandler => :tenant_shard,
+        Connections::MongoConnectionHandler => :tenant_mongo_db,
+        Connections::RedisConnectionHandler => :tenant_redis_db,
+        Connections::ElasticsearchConnectionHandler => :tenant_elasticsearch_prefix
+      }.freeze
+
+      attr_reader :ctx, :attributes
+
+      class << self
+        def for_context(ctx)
+          new(ctx, detect_attributes(ctx))
+        end
+
+        private
+
+        def detect_attributes(ctx)
+          methods = ctx.public_methods
+          partner_attrs(methods) + handler_attrs(methods)
+        end
+
+        def partner_attrs(methods)
+          methods.include?(:partner_identifier=) ? [:partner_identifier] : []
+        end
+
+        def handler_attrs(methods)
+          HANDLER_ATTRIBUTES.each_with_object([]) do |(handler, attr), list|
+            next unless methods.include?(:"#{attr}=")
+            next unless handler_available?(handler)
+
+            list << attr
+          end
+        end
+
+        def handler_available?(handler_class)
+          handler_class.new(nil).available?
+        rescue NotImplementedError, StandardError
+          false
+        end
+      end
+
+      def initialize(ctx, attributes)
+        @ctx = ctx
+        @attributes = attributes
+      end
+
+      def any_set?
+        attributes.any? { |attr| ctx.public_send(attr).present? }
+      end
+
+      def reset
+        attributes.each { |attr| ctx.public_send("#{attr}=", nil) }
+      end
+
+      def assign(constant, mapping)
+        attributes.map do |attr|
+          existing = safe_read(attr)
+          new_value = constant[mapping[attr]]
+          ctx.public_send("#{attr}=", new_value)
+          [attr, existing, new_value]
+        end
+      end
+
+      private
+
+      def safe_read(attr)
+        ctx.public_send(attr)
+      rescue StandardError
+        nil
+      end
+    end
+  end
+end

data/lib/console_kit/tenant_configurator.rb

@@ -2,53 +2,71 @@
 
 require_relative 'output'
 require_relative 'connections/connection_manager'
+require_relative 'connections/dashboard'
+require_relative 'tenant_configurator/context_wrapper'
 
 module ConsoleKit
   # For tenant configuration
   module TenantConfigurator
-    class << self
-      HANDLER_ATTRIBUTES = {
-        Connections::SqlConnectionHandler => :tenant_shard,
-        Connections::MongoConnectionHandler => :tenant_mongo_db,
-        Connections::RedisConnectionHandler => :tenant_redis_db,
-        Connections::ElasticsearchConnectionHandler => :tenant_elasticsearch_prefix
-      }.freeze
+    CONTEXT_MAPPING = {
+      partner_identifier: :partner_code,
+      tenant_shard: :shard,
+      tenant_mongo_db: :mongo_db,
+      tenant_redis_db: :redis_db,
+      tenant_elasticsearch_prefix: :elasticsearch_prefix
+    }.freeze
 
+    class << self
       def configuration_success = Thread.current[:console_kit_configuration_success]
 
       def configuration_success=(val)
         Thread.current[:console_kit_configuration_success] = val
       end
 
+      def current_tenant_key = Thread.current[:console_kit_current_tenant_key]
+
+      def current_tenant_key=(val)
+        Thread.current[:console_kit_current_tenant_key] = val
+      end
+
       def configure_tenant(key)
-        constants = ConsoleKit.configuration.tenants[key]&.[](:constants)
-        return missing_config_error(key) unless constants
+        return true if key == current_tenant_key && configuration_success
 
-        perform_configuration(key, constants)
+        attempt_configuration(key)
       rescue StandardError => e
-        handle_error(e, key)
+        handle_error?(e, key)
       end
 
       def clear
         ctx = ConsoleKit.configuration.context_class
         return unless ctx
 
-        reset_tenant(ctx)
-        Output.print_info('Tenant context has been cleared.')
+        perform_clear(ContextWrapper.for_context(ctx))
       end
 
       private
 
-      def reset_tenant(ctx)
-        self.configuration_success = false
-        reset_context_attributes(ctx)
-        setup_connections(ctx)
+      def attempt_configuration(key)
+        constants = ConsoleKit.configuration.tenants[key]&.[](:constants)
+        return missing_config_error?(key) unless constants
+
+        execute_configuration(key, constants)
+        configuration_success
       end
 
-      def reset_context_attributes(ctx)
-        available_context_attributes(ctx).each do |attr|
-          ctx.public_send("#{attr}=", nil)
-        end
+      def perform_clear(wrapper)
+        return unless configuration_success || wrapper.any_set?
+
+        reset_tenant(wrapper)
+        Output.print_info('Tenant context has been cleared.')
+        true
+      end
+
+      def reset_tenant(wrapper)
+        self.configuration_success = false
+        self.current_tenant_key = nil
+        wrapper.reset
+        setup_connections(wrapper.ctx)
       end
 
       def validate_constants!(constants)
@@ -56,64 +74,54 @@ module ConsoleKit
         raise Error, "Tenant constants missing keys: #{missing.join(', ')}" unless missing.empty?
       end
 
-      def missing_config_error(key)
+      def missing_config_error?(key)
         self.configuration_success = false
         Output.print_error("No configuration found for tenant: #{key}")
+        false
       end
 
-      def perform_configuration(key, constants)
+      def execute_configuration(key, constants)
         validate_constants!(constants)
         apply_context(constants)
-        configure_success(key)
-      end
-
-      def handler_available?(handler_class)
-        handler_class.new(nil).available?
-      rescue NotImplementedError, StandardError
-        false
-      end
-
-      def available_context_attributes(ctx)
-        attributes = %i[partner_identifier]
-        HANDLER_ATTRIBUTES.each do |handler, attr|
-          attributes << attr if handler_available?(handler) && ctx.respond_to?("#{attr}=")
-        end
-        attributes.select { |attr| ctx.respond_to?("#{attr}=") }
+        mark_success(key)
       end
 
       def apply_context(constant)
-        ctx = ConsoleKit.configuration.context_class
-        assign_context_attributes(ctx, constant)
-        setup_connections(ctx)
+        wrapper = ContextWrapper.for_context(ConsoleKit.configuration.context_class)
+        wrapper.assign(constant, CONTEXT_MAPPING).each do |attr, existing, configured|
+          warn_case_mismatch(attr, existing, configured) if case_mismatch?(existing, configured)
+        end
+        setup_connections(wrapper.ctx)
       end
 
-      def assign_context_attributes(ctx, constant)
-        attribute_to_constant = {
-          partner_identifier: :partner_code,
-          tenant_shard: :shard,
-          tenant_mongo_db: :mongo_db,
-          tenant_redis_db: :redis_db,
-          tenant_elasticsearch_prefix: :elasticsearch_prefix
-        }
-
-        available_context_attributes(ctx).each do |attr|
-          ctx.public_send("#{attr}=", constant[attribute_to_constant[attr]])
-        end
+      def case_mismatch?(existing, new_value)
+        existing.is_a?(String) && new_value.is_a?(String) &&
+          existing != new_value &&
+          existing.casecmp(new_value).zero?
       end
 
       def setup_connections(context)
-        ConsoleKit::Connections::ConnectionManager.available_handlers(context).each(&:connect)
+        Connections::ConnectionManager.available_handlers(context).each(&:connect)
       end
 
-      def configure_success(key)
+      def mark_success(key)
         Output.print_success("Tenant set to: #{key}")
         self.configuration_success = true
+        self.current_tenant_key = key
       end
 
-      def handle_error(error, key)
+      def warn_case_mismatch(attr, existing, configured)
+        Output.print_warning(
+          "#{attr} case mismatch: context had '#{existing}', config set '#{configured}'. " \
+          'Check your ConsoleKit tenant configuration.'
+        )
+      end
+
+      def handle_error?(error, key)
         self.configuration_success = false
         Output.print_error("Failed to configure tenant '#{key}': #{error.message}")
         Output.print_backtrace(error)
+        false
       end
     end
   end

data/lib/console_kit/tenant_orchestrator.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module ConsoleKit
+  # Orchestrates tenant lifecycle, selection, and configuration
+  class TenantOrchestrator
+    class << self
+      def auto_select? = (tenants.size == 1) || !$stdin.tty?
+
+      def current_tenant = Setup.current_tenant
+
+      def current_tenant=(val)
+        Setup.current_tenant = val
+      end
+
+      def reapply
+        return unless tenant_setup_successful?
+
+        Output.silence do
+          TenantConfigurator.current_tenant_key = nil
+          TenantConfigurator.configure_tenant(current_tenant)
+        end
+      end
+
+      def reset
+        return warn_no_tenants unless tenants?
+
+        perform_reset
+      end
+
+      def run
+        return if tenant_setup_successful?
+
+        perform_setup
+      rescue StandardError => e
+        handle_error(e)
+      end
+
+      def tenants = ConsoleKit.configuration.tenants
+      def tenants? = tenants&.any?
+      def select_tenant_key = auto_select? ? tenants.keys.first : TenantSelector.select
+      def warn_no_tenants = Output.print_warning('Cannot reset tenant: No tenants configured.')
+      def cancel_switch = Output.print_warning('Tenant switch cancelled.')
+      def skip_tenant_message = Output.print_info('No tenant selected. Loading without tenant configuration.')
+
+      private
+
+      def tenant_setup_successful? = !current_tenant.to_s.empty?
+
+      def perform_reset
+        key = select_tenant_key
+        return cancel_switch if key == :abort || key.blank?
+        return already_on_tenant?(key) if key == current_tenant
+
+        clear_current_tenant
+        return skip_tenant_message if %i[exit none].include?(key)
+
+        configure(key)
+      end
+
+      def perform_setup
+        ConsoleKit.configuration.validate!
+        key = select_tenant_key
+        return handle_selection_result(key) if %i[exit abort none].include?(key) || key.blank?
+
+        configure(key)
+      end
+
+      def handle_selection_result(key)
+        exit_on_key if %i[exit abort].include?(key)
+
+        skip_tenant_message if key == :none
+        Output.print_error('Tenant selection failed. Loading without tenant configuration.') if key.blank?
+      end
+
+      def exit_on_key
+        Output.print_info('Exiting console...')
+        Kernel.exit
+      end
+
+      def configure(key)
+        TenantConfigurator.configure_tenant(key)
+        return unless TenantConfigurator.configuration_success
+
+        Setup.current_tenant = key
+        Prompt.apply
+        SetupUI.print_tenant_banner(key, ConsoleKit.configuration)
+      end
+
+      def already_on_tenant?(key)
+        Output.print_info("Already using tenant: #{key}. No changes made.")
+        true
+      end
+
+      def clear_current_tenant
+        if current_tenant
+          Output.print_warning("Resetting tenant: #{current_tenant}")
+          TenantConfigurator.clear
+        end
+        self.current_tenant = nil
+      end
+
+      def handle_error(error)
+        Output.print_error("Error setting up tenant: #{error.message}")
+        Output.print_backtrace(error)
+      end
+    end
+  end
+end