console_kit 1.2.0 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ee9784d78350655db23efa1080d49d5e2527e1b6530ef7a1c2772974e57a89ec
-  data.tar.gz: 2edbd66f104e2a2e549d11991fbbdbd1f77118227dfad56122bb58baefd4ee72
+  metadata.gz: 348d99d0b8d74a78d96ffa4e74f7ee2baf25aab659700b5d44929d2e3cd87104
+  data.tar.gz: 9c5e7514f498818e2ffe8b0a9376511cbf364e81336a266df7fe02d143a26cf4
 SHA512:
-  metadata.gz: 92d30809eba5bb236130e2e472cb2ae8fc34f9ea0bd69b3a5c67334199cc34a9894666797ebe66c52489f8a2c22a403d1f65e097bfafdba89e3d3d9d5ec8d5b9
-  data.tar.gz: db949d61fdcff82557532b163dd1df0487e6e3fb6c3f0901eb172fa83b6adc87f70b191b59dca6405b76c90fad67c3b2c58aaff21161e441ae295e3dbdea116b
+  metadata.gz: 5e56f04db89485e9b0a3a23b667062a8998287a8ab9ad67dc793f3202730ba6f54dcf02f45ab65ff739e3aef23ec7c65574ba32c4aafe7cebc1a6dcff63c907f
+  data.tar.gz: 86d6d4457bb2ad62e8ac2ecdd22c3afc0fa72313f4625cf4b304bbd1f0436a67033e0a2c4190d995895b12aba4aef77c68465ffa1fe1dcf6815d93909f355394

data/lib/console_kit/configuration.rb

@@ -39,8 +39,9 @@ module ConsoleKit
     private
 
     def resolve_context_class(val)
-      val.to_s.constantize
-    rescue NameError
+      klass = val.to_s.safe_constantize
+      return klass if klass
+
       raise Error, "ConsoleKit: context_class '#{val}' could not be found. " \
                    'Ensure the class is defined before configuration is accessed.'
     end

data/lib/console_kit/connections/base_connection_handler.rb

@@ -29,7 +29,6 @@ module ConsoleKit
         if thread.join(timeout)
           result_wrapper[:value] || error_diagnostics(handler_name, StandardError.new('Unknown error'))
         else
-          thread.kill
           timeout_diagnostics(handler_name, timeout)
         end
       end
@@ -38,29 +37,24 @@ module ConsoleKit
 
       def spawn_diagnostic_thread(handler_name)
         wrapper = { value: nil }
-        thread = Thread.new { wrapper[:value] = run_diagnostics_safely(handler_name) }
+        thread = Thread.new { wrapper[:value] = run_diagnostics_safely(handler_name) { diagnostics } }
         [thread, wrapper]
       end
 
       def run_diagnostics_safely(name)
-        diagnostics
+        yield
       rescue StandardError => e
         error_diagnostics(name, e)
       end
 
-      def context_attribute(name)
-        @context.respond_to?(name, true) ? @context.send(name) : nil
-      end
-
       def measure_latency
         start = clock_time
         yield
         ((clock_time - start) * 1000).round(1)
       end
 
-      def unavailable_diagnostics(name)
-        { name: name, status: :unavailable, latency_ms: nil, details: {} }
-      end
+      def context_attribute(name) = @context.try(name)
+      def unavailable_diagnostics(name) = { name: name, status: :unavailable, latency_ms: nil, details: {} }
     end
   end
 end

data/lib/console_kit/connections/elasticsearch_connection_handler.rb

@@ -6,54 +6,66 @@ module ConsoleKit
   module Connections
     # Handles Elasticsearch connections
     class ElasticsearchConnectionHandler < BaseConnectionHandler
+      class << self
+        def elasticsearch_available?
+          return false unless defined?(Elasticsearch::Model)
+
+          Elasticsearch::Model.method(:client)
+          true
+        rescue NameError
+          false
+        end
+
+        def apply_prefix(prefix)
+          return unless defined?(Elasticsearch::Model)
+
+          Elasticsearch::Model.try(:index_name_prefix=, prefix)
+        end
+      end
+
       def connect
         prefix = context_attribute(:tenant_elasticsearch_prefix).presence
         Output.print_info(switch_message(prefix))
         Thread.current[:console_kit_elasticsearch_prefix] = prefix
-        apply_model_index_prefix(prefix)
+        self.class.apply_prefix(prefix)
       end
 
-      def available?
-        !!(defined?(Elasticsearch::Model) && Elasticsearch::Model.respond_to?(:client))
-      end
+      def available? = self.class.elasticsearch_available?
 
       def diagnostics
-        name = 'Elasticsearch'
-        return unavailable_diagnostics(name) unless available?
+        return unavailable_diagnostics('Elasticsearch') unless available?
 
-        client = Elasticsearch::Model.client
-        latency = measure_latency { client.ping }
-        build_elasticsearch_diagnostics(client, latency)
+        perform_diagnostics
       rescue StandardError => e
-        error_diagnostics(name, e)
+        error_diagnostics('Elasticsearch', e)
       end
 
       private
 
-      def build_elasticsearch_diagnostics(client, latency)
+      def perform_diagnostics
+        client = Elasticsearch::Model.client
+        latency = measure_latency do
+          client.ping
+        rescue StandardError
+          nil
+        end
+        health = client.cluster.health
+        build_elasticsearch_diagnostics(health['cluster_name'], health['status'], latency)
+      end
+
+      def build_elasticsearch_diagnostics(cluster, status, latency)
         {
           name: 'Elasticsearch',
           status: :connected,
           latency_ms: latency,
-          details: elasticsearch_details(client.cluster.health)
-        }
-      end
-
-      def elasticsearch_details(health)
-        {
-          prefix: context_attribute(:tenant_elasticsearch_prefix),
-          cluster: health['cluster_name'],
-          health: health['status']
+          details: {
+            prefix: context_attribute(:tenant_elasticsearch_prefix),
+            cluster: cluster,
+            health: status
+          }
         }
       end
 
-      def apply_model_index_prefix(prefix)
-        return unless defined?(Elasticsearch::Model)
-        return unless Elasticsearch::Model.respond_to?(:index_name_prefix=)
-
-        Elasticsearch::Model.index_name_prefix = prefix
-      end
-
       def switch_message(prefix)
         prefix ? "Setting Elasticsearch index prefix: #{prefix}" : 'Resetting Elasticsearch index prefix to default'
       end

data/lib/console_kit/connections/mongo_connection_handler.rb

@@ -8,51 +8,67 @@ module ConsoleKit
     class MongoConnectionHandler < BaseConnectionHandler
       def connect
         db = context_attribute(:tenant_mongo_db).presence
-        Output.print_info(switch_message(db))
-        Mongoid.override_database(db)
+        switch_mongo(db)
       rescue NoMethodError
-        Output.print_warning('Mongoid.override_database is not available in this version of Mongoid.')
+        Output.print_warning('Mongoid client override is not available in this version of Mongoid.')
       end
 
       def available? = defined?(Mongoid)
 
       def diagnostics
-        name = 'MongoDB'
-        return unavailable_diagnostics(name) unless available?
+        return unavailable_diagnostics('MongoDB') unless available?
 
-        db = tenant_database
-        latency = measure_latency { db.command(ping: 1) }
-        build_mongo_diagnostics(db, latency)
+        perform_diagnostics
       rescue StandardError => e
-        error_diagnostics(name, e)
+        error_diagnostics('MongoDB', e)
       end
 
       private
 
-      def tenant_database
-        override = context_attribute(:tenant_mongo_db).presence
-        client = Mongoid.default_client
-        return client.database unless override
-
-        client.use(override).database
+      def perform_diagnostics
+        db = tenant_database
+        latency = measure_latency { db.command(ping: 1) }
+        info = db.command(buildInfo: 1).first
+        build_mongo_diagnostics(db.name, info['version'], latency)
       end
 
-      def build_mongo_diagnostics(database, latency)
-        build_info = database.command(buildInfo: 1).first
+      def build_mongo_diagnostics(name, version, latency)
         {
           name: 'MongoDB',
           status: :connected,
           latency_ms: latency,
-          details: mongo_details(database.name, build_info['version'])
+          details: { database: name, version: version }
         }
       end
 
-      def mongo_details(name, version)
-        { database: name, version: version }
+      def tenant_database
+        override = context_attribute(:tenant_mongo_db).presence
+        client = Mongoid.default_client
+        (override ? client.use(override) : client).database
+      end
+
+      def switch_mongo(db)
+        if db.nil?
+          Output.print_info('Resetting MongoDB client to default')
+          reset_overrides
+        elsif named_client?(db)
+          Output.print_info("Switching to MongoDB client: #{db}")
+          Mongoid.override_client(db)
+        else
+          Output.print_info("Switching to MongoDB database: #{db}")
+          Mongoid.override_database(db)
+        end
+      end
+
+      def reset_overrides
+        Mongoid.override_client(nil) if Mongoid.respond_to?(:override_client)
+        Mongoid.override_database(nil)
       end
 
-      def switch_message(db)
-        db ? "Switching to MongoDB client: #{db}" : 'Resetting MongoDB client to default'
+      def named_client?(name)
+        Mongoid::Config.clients.key?(name.to_s)
+      rescue StandardError
+        false
       end
     end
   end

data/lib/console_kit/connections/redis_connection_handler.rb

@@ -8,68 +8,67 @@ module ConsoleKit
     class RedisConnectionHandler < BaseConnectionHandler
       DEFAULT_REDIS_DB = 0
 
+      class << self
+        def redis_client = Redis.try(:current)
+
+        def warn_no_auto_select(db_index)
+          Output.print_warning("Redis DB #{db_index} configured but auto-select not supported with RedisClient. " \
+                               'Ensure your Redis configuration sets the correct DB.')
+        end
+      end
+
       def connect
-        db = context_attribute(:tenant_redis_db) || DEFAULT_REDIS_DB
-        Output.print_info(switch_message(db))
-        select_redis_db(db)
+        db_index = context_attribute(:tenant_redis_db) || DEFAULT_REDIS_DB
+        Output.print_info(switch_message(db_index))
+        select_redis_db(db_index)
       end
 
       def available? = defined?(Redis)
 
       def diagnostics
-        name = 'Redis'
-        return unavailable_diagnostics(name) unless available?
+        redis = self.class.redis_client if available?
+        return unavailable_diagnostics('Redis') unless redis
 
-        redis = fetch_redis_client
-        return unavailable_diagnostics(name) unless redis
-
-        latency = measure_latency { redis.ping }
-        build_redis_diagnostics(redis.info, latency)
+        perform_diagnostics(redis)
       rescue StandardError => e
-        error_diagnostics(name, e)
+        error_diagnostics('Redis', e)
       end
 
       private
 
-      def fetch_redis_client
-        Redis.respond_to?(:current) && Redis.current
+      def perform_diagnostics(redis)
+        latency = measure_latency { redis.ping }
+        info = redis.info
+        build_redis_diagnostics(info['redis_version'], info['used_memory_human'], latency)
       end
 
-      def build_redis_diagnostics(info, latency)
+      def build_redis_diagnostics(version, memory, latency)
         {
           name: 'Redis',
           status: :connected,
           latency_ms: latency,
-          details: redis_details(info)
+          details: {
+            db: context_attribute(:tenant_redis_db) || DEFAULT_REDIS_DB,
+            version: version,
+            memory: memory
+          }
         }
       end
 
-      def redis_details(info)
-        {
-          db: context_attribute(:tenant_redis_db) || DEFAULT_REDIS_DB,
-          version: info['redis_version'],
-          memory: info['used_memory_human']
-        }
-      end
-
-      def select_redis_db(db)
-        redis = fetch_redis_client
+      def select_redis_db(db_index)
+        klass = self.class
+        redis = klass.redis_client
         if redis
-          redis.select(db)
-        elsif defined?(RedisClient) && db != DEFAULT_REDIS_DB
-          warn_about_redis_client(db)
+          redis.select(db_index)
+        elsif defined?(RedisClient) && db_index != DEFAULT_REDIS_DB
+          klass.warn_no_auto_select(db_index)
         end
       rescue NoMethodError
         Output.print_warning('Redis.current is not available (deprecated in Redis v5+).')
       end
 
-      def warn_about_redis_client(db)
-        Output.print_warning("Redis DB #{db} configured but auto-select not supported with RedisClient. " \
-                             'Ensure your Redis configuration sets the correct DB.')
-      end
-
-      def switch_message(db)
-        db ? "Switching to Redis DB: #{db}" : 'Resetting Redis connection to default'
+      def switch_message(db_index)
+        db_index ? "Switching to Redis DB: #{db_index}" : 'Resetting Redis connection to default'
       end
     end
   end

data/lib/console_kit/connections/sql_connection_handler.rb

@@ -6,6 +6,16 @@ module ConsoleKit
   module Connections
     # Handles SQL connections
     class SqlConnectionHandler < BaseConnectionHandler
+      class << self
+        def sql_version(conn)
+          conn.select_value('SELECT version()')
+        rescue StandardError
+          nil
+        end
+
+        def base_class_name = ConsoleKit.configuration.sql_base_class
+      end
+
       def connect
         shard = context_attribute(:tenant_shard).presence&.to_sym
         Output.print_info("#{connection_message(shard)} via #{base_class}")
@@ -13,25 +23,26 @@ module ConsoleKit
         shard ? base_class.establish_connection(shard) : base_class.establish_connection
       end
 
-      def available? = sql_base_class_name.to_s.safe_constantize.present?
+      def available? = self.class.base_class_name.to_s.safe_constantize.present?
 
       def diagnostics
-        name = 'SQL'
-        return unavailable_diagnostics(name) unless available?
+        return unavailable_diagnostics('SQL') unless available?
 
-        conn = base_class.connection
-        latency = measure_latency { conn.execute('SELECT 1') }
-        build_sql_diagnostics(conn, latency)
+        perform_diagnostics
       rescue StandardError => e
-        error_diagnostics(name, e)
+        error_diagnostics('SQL', e)
       end
 
       private
 
-      def disconnect_existing_pool
-        return unless base_class.respond_to?(:connection_pool)
+      def perform_diagnostics
+        conn = base_class.connection
+        latency = measure_latency { conn.execute('SELECT 1') }
+        build_sql_diagnostics(conn, latency)
+      end
 
-        pool = base_class.connection_pool
+      def disconnect_existing_pool
+        pool = base_class.try(:connection_pool)
         pool&.disconnect!
       end
 
@@ -43,29 +54,22 @@ module ConsoleKit
           details: {
             adapter: conn.adapter_name,
             pool_size: base_class.connection_pool.size,
-            version: fetch_sql_version(conn).to_s.truncate(50)
+            version: self.class.sql_version(conn).to_s.truncate(50)
           }
         }
       end
 
-      def fetch_sql_version(conn)
-        conn.select_value('SELECT version()')
-      rescue StandardError
-        nil
-      end
-
       def base_class
-        klass = sql_base_class_name.to_s.safe_constantize
-        return klass if klass
-
-        raise Error, "ConsoleKit: sql_base_class '#{sql_base_class_name}' could not be found."
+        @base_class ||= begin
+          name = self.class.base_class_name
+          klass = name.to_s.safe_constantize
+          klass || raise(Error, "ConsoleKit: sql_base_class '#{name}' could not be found.")
+        end
       end
 
       def connection_message(shard)
         shard ? "Establishing SQL connection to shard: #{shard}" : 'Resetting SQL connection to default'
       end
-
-      def sql_base_class_name = ConsoleKit.configuration.sql_base_class
     end
   end
 end

data/lib/console_kit/console_helpers.rb

@@ -3,24 +3,27 @@
 module ConsoleKit
   # Helper methods available in the Rails console
   module ConsoleHelpers
-    def switch_tenant = ConsoleKit.reset_current_tenant
+    def switch_tenant
+      ConsoleKit.reset_current_tenant
+      self
+    end
 
     def tenant_info
       tenant = ConsoleKit::Setup.current_tenant
-      unless tenant
-        ConsoleKit::Output.print_warning('No tenant is currently configured.')
-        return
-      end
+      return no_tenant_warning unless tenant
 
-      constants = ConsoleKit.configuration.tenants[tenant]&.[](:constants) || {}
-      print_tenant_details(tenant, constants)
+      display_tenant_info(tenant)
+      nil
     end
 
-    def dashboard = ConsoleKit::Connections::Dashboard.display
+    def dashboard
+      ConsoleKit::Connections::Dashboard.display
+      self
+    end
 
     def tenants
       names = ConsoleKit.configuration.tenants&.keys || []
-      ConsoleKit::Output.print_list(names, header: 'Available Tenants')
+      print_available_tenants(names)
       names
     end
 
@@ -31,17 +34,31 @@ module ConsoleKit
 
     private
 
-    def print_tenant_details(tenant, constants)
-      ConsoleKit::Output.print_header("Tenant: #{tenant}")
-      DETAIL_LABELS.each do |label, key|
-        constants.fetch(key, :missing).then do |val|
-          case val
-          when :missing then next
-          else ConsoleKit::Output.print_info("  #{label.ljust(13)}#{val}")
-          end
+    def no_tenant_warning
+      ConsoleKit::Output.print_warning('No tenant is currently configured.')
+      self
+    end
+
+    def display_tenant_info(tenant)
+      constants = ConsoleKit.configuration.tenants[tenant]&.[](:constants) || {}
+      ConsoleHelpers.print_tenant_details(tenant, constants)
+      self
+    end
+
+    def print_available_tenants(names)
+      ConsoleKit::Output.print_list(names, header: 'Available Tenants')
+      self
+    end
+
+    class << self
+      def print_tenant_details(tenant, constants)
+        ConsoleKit::Output.print_header("Tenant: #{tenant}")
+        DETAIL_LABELS.each do |label, key|
+          next unless constants.key?(key)
+
+          ConsoleKit::Output.print_info("  #{label.ljust(13)}#{constants[key]}")
         end
       end
-      nil
     end
   end
 end

data/lib/console_kit/output.rb

@@ -63,12 +63,21 @@ module ConsoleKit
 
       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], opts[:timestamp])
-        color = meta[:color]
-        formatted = ConsoleKit.configuration.pretty_output && color ? "\e[#{color}m#{message}\e[0m" : message
+        message = build_message(text, meta[:symbol], timestamp)
+        colorize(message, meta[:color])
+      end
+
+      def colorize(message, color)
+        return message unless ConsoleKit.configuration.pretty_output && color
 
-        opts.fetch(:newline, true) ? puts(formatted) : print(formatted)
+        "\e[#{color}m#{message}\e[0m"
       end
 
       def build_message(text, symbol, timestamp)

data/lib/console_kit/prompt.rb

@@ -41,11 +41,9 @@ module ConsoleKit
       end
 
       def build_pry_prompt(procs)
-        if defined?(Pry::Prompt) && Pry::Prompt.respond_to?(:new)
-          Pry::Prompt.new('console_kit', 'ConsoleKit tenant prompt', procs)
-        else
-          procs
-        end
+        return procs unless defined?(Pry::Prompt)
+
+        Pry::Prompt.try(:new, 'console_kit', 'ConsoleKit tenant prompt', procs) || procs
       end
     end
   end

data/lib/console_kit/setup.rb

@@ -4,6 +4,7 @@ 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
@@ -16,91 +17,11 @@ module ConsoleKit
         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?
-
-        perform_tenant_reset
-      end
-
-      private
-
-      def perform_tenant_reset
-        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
-
-      def run_setup
-        return if tenant_setup_successful?
-
-        config = ConsoleKit.configuration
-        config.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)
-
-        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
-
-        self.current_tenant = key
-        Prompt.apply
-        SetupUI.print_tenant_banner(key, ConsoleKit.configuration)
-      end
-
-      def tenants = ConsoleKit.configuration.tenants
-      def tenants? = tenants&.any?
-      def select_tenant_key = auto_select? ? tenants.keys.first : TenantSelector.select
-      def auto_select? = (tenants.size == 1) || !$stdin.tty?
-      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.')
-
-      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
+      def reapply = TenantOrchestrator.reapply
+      def reset_current_tenant = TenantOrchestrator.reset
+      def auto_select? = TenantOrchestrator.auto_select?
     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

@@ -3,53 +3,70 @@
 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)
@@ -57,67 +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 = ctx.respond_to?(:partner_identifier=) ? [:partner_identifier] : []
-
-        HANDLER_ATTRIBUTES.each_with_object(attributes) do |(handler, attr), list|
-          next unless ctx.respond_to?("#{attr}=")
-          next unless handler_available?(handler)
-
-          list << attr
-        end
+        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 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)
+      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

data/lib/console_kit/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ConsoleKit
-  VERSION = '1.2.0'
+  VERSION = '1.3.0'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: console_kit
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 1.3.0
 platform: ruby
 authors:
 - Soumyadeep Pal
@@ -58,6 +58,8 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".DS_Store"
+- ".reek.yml.new"
 - LICENSE.txt
 - lib/console_kit.rb
 - lib/console_kit/configuration.rb
@@ -78,6 +80,8 @@ files:
 - lib/console_kit/setup.rb
 - lib/console_kit/setup_ui.rb
 - lib/console_kit/tenant_configurator.rb
+- lib/console_kit/tenant_configurator/context_wrapper.rb
+- lib/console_kit/tenant_orchestrator.rb
 - lib/console_kit/tenant_selector.rb
 - lib/console_kit/version.rb
 - lib/generators/console_kit/install_generator.rb