tokite 4.0.0 → 5.0.0

data/vendor/bundle/ruby/3.4.0/gems/activerecord-8.0.4/lib/active_record/base.rb

@@ -1,338 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/benchmarkable"
-require "active_support/dependencies"
-require "active_support/descendants_tracker"
-require "active_support/time"
-require "active_support/core_ext/class/subclasses"
-require "active_record/log_subscriber"
-require "active_record/explain_subscriber"
-require "active_record/relation/delegation"
-require "active_record/attributes"
-require "active_record/type_caster"
-require "active_record/database_configurations"
-
-module ActiveRecord # :nodoc:
-  # = Active Record
-  #
-  # Active Record objects don't specify their attributes directly, but rather infer them from
-  # the table definition with which they're linked. Adding, removing, and changing attributes
-  # and their type is done directly in the database. Any change is instantly reflected in the
-  # Active Record objects. The mapping that binds a given Active Record class to a certain
-  # database table will happen automatically in most common cases, but can be overwritten for the uncommon ones.
-  #
-  # See the mapping rules in table_name and the full example in link:files/activerecord/README_rdoc.html for more insight.
-  #
-  # == Creation
-  #
-  # Active Records accept constructor parameters either in a hash or as a block. The hash
-  # method is especially useful when you're receiving the data from somewhere else, like an
-  # HTTP request. It works like this:
-  #
-  #   user = User.new(name: "David", occupation: "Code Artist")
-  #   user.name # => "David"
-  #
-  # You can also use block initialization:
-  #
-  #   user = User.new do |u|
-  #     u.name = "David"
-  #     u.occupation = "Code Artist"
-  #   end
-  #
-  # And of course you can just create a bare object and specify the attributes after the fact:
-  #
-  #   user = User.new
-  #   user.name = "David"
-  #   user.occupation = "Code Artist"
-  #
-  # == Conditions
-  #
-  # Conditions can either be specified as a string, array, or hash representing the WHERE-part of an SQL statement.
-  # The array form is to be used when the condition input is tainted and requires sanitization. The string form can
-  # be used for statements that don't involve tainted data. The hash form works much like the array form, except
-  # only equality and range is possible. Examples:
-  #
-  #   class User < ActiveRecord::Base
-  #     def self.authenticate_unsafely(user_name, password)
-  #       where("user_name = '#{user_name}' AND password = '#{password}'").first
-  #     end
-  #
-  #     def self.authenticate_safely(user_name, password)
-  #       where("user_name = ? AND password = ?", user_name, password).first
-  #     end
-  #
-  #     def self.authenticate_safely_simply(user_name, password)
-  #       where(user_name: user_name, password: password).first
-  #     end
-  #   end
-  #
-  # The <tt>authenticate_unsafely</tt> method inserts the parameters directly into the query
-  # and is thus susceptible to SQL-injection attacks if the <tt>user_name</tt> and +password+
-  # parameters come directly from an HTTP request. The <tt>authenticate_safely</tt> and
-  # <tt>authenticate_safely_simply</tt> both will sanitize the <tt>user_name</tt> and +password+
-  # before inserting them in the query, which will ensure that an attacker can't escape the
-  # query and fake the login (or worse).
-  #
-  # When using multiple parameters in the conditions, it can easily become hard to read exactly
-  # what the fourth or fifth question mark is supposed to represent. In those cases, you can
-  # resort to named bind variables instead. That's done by replacing the question marks with
-  # symbols and supplying a hash with values for the matching symbol keys:
-  #
-  #   Company.where(
-  #     "id = :id AND name = :name AND division = :division AND created_at > :accounting_date",
-  #     { id: 3, name: "37signals", division: "First", accounting_date: '2005-01-01' }
-  #   ).first
-  #
-  # Similarly, a simple hash without a statement will generate conditions based on equality with the SQL AND
-  # operator. For instance:
-  #
-  #   Student.where(first_name: "Harvey", status: 1)
-  #   Student.where(params[:student])
-  #
-  # A range may be used in the hash to use the SQL BETWEEN operator:
-  #
-  #   Student.where(grade: 9..12)
-  #
-  # An array may be used in the hash to use the SQL IN operator:
-  #
-  #   Student.where(grade: [9,11,12])
-  #
-  # When joining tables, nested hashes or keys written in the form 'table_name.column_name'
-  # can be used to qualify the table name of a particular condition. For instance:
-  #
-  #   Student.joins(:schools).where(schools: { category: 'public' })
-  #   Student.joins(:schools).where('schools.category' => 'public' )
-  #
-  # == Overwriting default accessors
-  #
-  # All column values are automatically available through basic accessors on the Active Record
-  # object, but sometimes you want to specialize this behavior. This can be done by overwriting
-  # the default accessors (using the same name as the attribute) and calling
-  # +super+ to actually change things.
-  #
-  #   class Song < ActiveRecord::Base
-  #     # Uses an integer of seconds to hold the length of the song
-  #
-  #     def length=(minutes)
-  #       super(minutes.to_i * 60)
-  #     end
-  #
-  #     def length
-  #       super / 60
-  #     end
-  #   end
-  #
-  # == Attribute query methods
-  #
-  # In addition to the basic accessors, query methods are also automatically available on the Active Record object.
-  # Query methods allow you to test whether an attribute value is present.
-  # Additionally, when dealing with numeric values, a query method will return false if the value is zero.
-  #
-  # For example, an Active Record User with the <tt>name</tt> attribute has a <tt>name?</tt> method that you can call
-  # to determine whether the user has a name:
-  #
-  #   user = User.new(name: "David")
-  #   user.name? # => true
-  #
-  #   anonymous = User.new(name: "")
-  #   anonymous.name? # => false
-  #
-  # Query methods will also respect any overrides of default accessors:
-  #
-  #   class User
-  #     # Has admin boolean column
-  #     def admin
-  #       false
-  #     end
-  #   end
-  #
-  #   user.update(admin: true)
-  #
-  #   user.read_attribute(:admin)  # => true, gets the column value
-  #   user[:admin] # => true, also gets the column value
-  #
-  #   user.admin   # => false, due to the getter override
-  #   user.admin?  # => false, due to the getter override
-  #
-  # == Accessing attributes before they have been typecasted
-  #
-  # Sometimes you want to be able to read the raw attribute data without having the column-determined
-  # typecast run its course first. That can be done by using the <tt><attribute>_before_type_cast</tt>
-  # accessors that all attributes have. For example, if your Account model has a <tt>balance</tt> attribute,
-  # you can call <tt>account.balance_before_type_cast</tt> or <tt>account.id_before_type_cast</tt>.
-  #
-  # This is especially useful in validation situations where the user might supply a string for an
-  # integer field and you want to display the original string back in an error message. Accessing the
-  # attribute normally would typecast the string to 0, which isn't what you want.
-  #
-  # == Dynamic attribute-based finders
-  #
-  # Dynamic attribute-based finders are a mildly deprecated way of getting (and/or creating) objects
-  # by simple queries without turning to SQL. They work by appending the name of an attribute
-  # to <tt>find_by_</tt> like <tt>Person.find_by_user_name</tt>.
-  # Instead of writing <tt>Person.find_by(user_name: user_name)</tt>, you can use
-  # <tt>Person.find_by_user_name(user_name)</tt>.
-  #
-  # It's possible to add an exclamation point (!) on the end of the dynamic finders to get them to raise an
-  # ActiveRecord::RecordNotFound error if they do not return any records,
-  # like <tt>Person.find_by_last_name!</tt>.
-  #
-  # It's also possible to use multiple attributes in the same <tt>find_by_</tt> by separating them with
-  # "_and_".
-  #
-  #  Person.find_by(user_name: user_name, password: password)
-  #  Person.find_by_user_name_and_password(user_name, password) # with dynamic finder
-  #
-  # It's even possible to call these dynamic finder methods on relations and named scopes.
-  #
-  #   Payment.order("created_on").find_by_amount(50)
-  #
-  # == Saving arrays, hashes, and other non-mappable objects in text columns
-  #
-  # Active Record can serialize any object in text columns using YAML. To do so, you must
-  # specify this with a call to the class method
-  # {serialize}[rdoc-ref:AttributeMethods::Serialization::ClassMethods#serialize].
-  # This makes it possible to store arrays, hashes, and other non-mappable objects without doing
-  # any additional work.
-  #
-  #   class User < ActiveRecord::Base
-  #     serialize :preferences
-  #   end
-  #
-  #   user = User.create(preferences: { "background" => "black", "display" => large })
-  #   User.find(user.id).preferences # => { "background" => "black", "display" => large }
-  #
-  # You can also specify a class option as the second parameter that'll raise an exception
-  # if a serialized object is retrieved as a descendant of a class not in the hierarchy.
-  #
-  #   class User < ActiveRecord::Base
-  #     serialize :preferences, Hash
-  #   end
-  #
-  #   user = User.create(preferences: %w( one two three ))
-  #   User.find(user.id).preferences    # raises SerializationTypeMismatch
-  #
-  # When you specify a class option, the default value for that attribute will be a new
-  # instance of that class.
-  #
-  #   class User < ActiveRecord::Base
-  #     serialize :preferences, OpenStruct
-  #   end
-  #
-  #   user = User.new
-  #   user.preferences.theme_color = "red"
-  #
-  #
-  # == Single table inheritance
-  #
-  # Active Record allows inheritance by storing the name of the class in a
-  # column that is named "type" by default. See ActiveRecord::Inheritance for
-  # more details.
-  #
-  # == Connection to multiple databases in different models
-  #
-  # Connections are usually created through
-  # {ActiveRecord::Base.establish_connection}[rdoc-ref:ConnectionHandling#establish_connection] and retrieved
-  # by ActiveRecord::Base.lease_connection. All classes inheriting from ActiveRecord::Base will use this
-  # connection. But you can also set a class-specific connection. For example, if Course is an
-  # ActiveRecord::Base, but resides in a different database, you can just say <tt>Course.establish_connection</tt>
-  # and Course and all of its subclasses will use this connection instead.
-  #
-  # This feature is implemented by keeping a connection pool in ActiveRecord::Base that is
-  # a hash indexed by the class. If a connection is requested, the
-  # {ActiveRecord::Base.retrieve_connection}[rdoc-ref:ConnectionHandling#retrieve_connection] method
-  # will go up the class-hierarchy until a connection is found in the connection pool.
-  #
-  # == Exceptions
-  #
-  # * ActiveRecordError - Generic error class and superclass of all other errors raised by Active Record.
-  # * AdapterNotSpecified - The configuration hash used in
-  #   {ActiveRecord::Base.establish_connection}[rdoc-ref:ConnectionHandling#establish_connection]
-  #   didn't include an <tt>:adapter</tt> key.
-  # * AdapterNotFound - The <tt>:adapter</tt> key used in
-  #   {ActiveRecord::Base.establish_connection}[rdoc-ref:ConnectionHandling#establish_connection]
-  #   specified a non-existent adapter
-  #   (or a bad spelling of an existing one).
-  # * AssociationTypeMismatch - The object assigned to the association wasn't of the type
-  #   specified in the association definition.
-  # * AttributeAssignmentError - An error occurred while doing a mass assignment through the
-  #   {ActiveRecord::Base#attributes=}[rdoc-ref:ActiveModel::AttributeAssignment#attributes=] method.
-  #   You can inspect the +attribute+ property of the exception object to determine which attribute
-  #   triggered the error.
-  # * ConnectionNotEstablished - No connection has been established.
-  #   Use {ActiveRecord::Base.establish_connection}[rdoc-ref:ConnectionHandling#establish_connection] before querying.
-  # * MultiparameterAssignmentErrors - Collection of errors that occurred during a mass assignment using the
-  #   {ActiveRecord::Base#attributes=}[rdoc-ref:ActiveModel::AttributeAssignment#attributes=] method.
-  #   The +errors+ property of this exception contains an array of
-  #   AttributeAssignmentError
-  #   objects that should be inspected to determine which attributes triggered the errors.
-  # * RecordInvalid - raised by {ActiveRecord::Base#save!}[rdoc-ref:Persistence#save!] and
-  #   {ActiveRecord::Base.create!}[rdoc-ref:Persistence::ClassMethods#create!]
-  #   when the record is invalid.
-  # * RecordNotFound - No record responded to the {ActiveRecord::Base.find}[rdoc-ref:FinderMethods#find] method.
-  #   Either the row with the given ID doesn't exist or the row didn't meet the additional restrictions.
-  #   Some {ActiveRecord::Base.find}[rdoc-ref:FinderMethods#find] calls do not raise this exception to signal
-  #   nothing was found, please check its documentation for further details.
-  # * SerializationTypeMismatch - The serialized object wasn't of the class specified as the second parameter.
-  # * StatementInvalid - The database server rejected the SQL statement. The precise error is added in the message.
-  #
-  # *Note*: The attributes listed are class-level attributes (accessible from both the class and instance level).
-  # So it's possible to assign a logger to the class through <tt>Base.logger=</tt> which will then be used by all
-  # instances in the current object space.
-  class Base
-    include ActiveModel::API
-
-    extend ActiveSupport::Benchmarkable
-    extend ActiveSupport::DescendantsTracker
-
-    extend ConnectionHandling
-    extend QueryCache::ClassMethods
-    extend Querying
-    extend Translation
-    extend DynamicMatchers
-    extend DelegatedType
-    extend Explain
-    extend Enum
-    extend Delegation::DelegateCache
-    extend Aggregations::ClassMethods
-
-    include Core
-    include Persistence
-    include ReadonlyAttributes
-    include ModelSchema
-    include Inheritance
-    include Scoping
-    include Sanitization
-    include AttributeAssignment
-    include Integration
-    include Validations
-    include CounterCache
-    include Attributes
-    include Locking::Optimistic
-    include Locking::Pessimistic
-    include Encryption::EncryptableRecord
-    include AttributeMethods
-    include Callbacks
-    include Timestamp
-    include Associations
-    include SecurePassword
-    include AutosaveAssociation
-    include NestedAttributes
-    include Transactions
-    include TouchLater
-    include NoTouching
-    include Reflection
-    include Serialization
-    include Store
-    include SecureToken
-    include TokenFor
-    include SignedId
-    include Suppressor
-    include Normalization
-    include Marshalling::Methods
-
-    self.param_delimiter = "_"
-  end
-
-  ActiveSupport.run_load_hooks(:active_record, Base)
-end

data/vendor/bundle/ruby/3.4.0/gems/activerecord-8.0.4/lib/active_record/coders/json.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveRecord
-  module Coders # :nodoc:
-    module JSON # :nodoc:
-      def self.dump(obj)
-        ActiveSupport::JSON.encode(obj)
-      end
-
-      def self.load(json)
-        ActiveSupport::JSON.decode(json) unless json.blank?
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/3.4.0/gems/activerecord-8.0.4/lib/active_record/connection_adapters/abstract/connection_handler.rb

@@ -1,293 +0,0 @@
-# frozen_string_literal: true
-
-require "concurrent/map"
-
-module ActiveRecord
-  module ConnectionAdapters
-    # = Active Record Connection Handler
-    #
-    # ConnectionHandler is a collection of ConnectionPool objects. It is used
-    # for keeping separate connection pools that connect to different databases.
-    #
-    # For example, suppose that you have 5 models, with the following hierarchy:
-    #
-    #   class Author < ActiveRecord::Base
-    #   end
-    #
-    #   class BankAccount < ActiveRecord::Base
-    #   end
-    #
-    #   class Book < ActiveRecord::Base
-    #     establish_connection :library_db
-    #   end
-    #
-    #   class ScaryBook < Book
-    #   end
-    #
-    #   class GoodBook < Book
-    #   end
-    #
-    # And a database.yml that looked like this:
-    #
-    #   development:
-    #     database: my_application
-    #     host: localhost
-    #
-    #   library_db:
-    #     database: library
-    #     host: some.library.org
-    #
-    # Your primary database in the development environment is "my_application"
-    # but the Book model connects to a separate database called "library_db"
-    # (this can even be a database on a different machine).
-    #
-    # Book, ScaryBook, and GoodBook will all use the same connection pool to
-    # "library_db" while Author, BankAccount, and any other models you create
-    # will use the default connection pool to "my_application".
-    #
-    # The various connection pools are managed by a single instance of
-    # ConnectionHandler accessible via ActiveRecord::Base.connection_handler.
-    # All Active Record models use this handler to determine the connection pool that they
-    # should use.
-    #
-    # The ConnectionHandler class is not coupled with the Active models, as it has no knowledge
-    # about the model. The model needs to pass a connection specification name to the handler,
-    # in order to look up the correct connection pool.
-    class ConnectionHandler
-      class ConnectionDescriptor # :nodoc:
-        def initialize(name, primary = false)
-          @name = name
-          @primary = primary
-        end
-
-        def name
-          primary_class? ? "ActiveRecord::Base" : @name
-        end
-
-        def primary_class?
-          @primary
-        end
-
-        def current_preventing_writes
-          ActiveRecord::Base.preventing_writes?(@name)
-        end
-      end
-
-      def initialize
-        # These caches are keyed by pool_config.connection_name (PoolConfig#connection_name).
-        @connection_name_to_pool_manager = Concurrent::Map.new(initial_capacity: 2)
-      end
-
-      def prevent_writes # :nodoc:
-        ActiveSupport::IsolatedExecutionState[:active_record_prevent_writes]
-      end
-
-      def prevent_writes=(prevent_writes) # :nodoc:
-        ActiveSupport::IsolatedExecutionState[:active_record_prevent_writes] = prevent_writes
-      end
-
-      def connection_pool_names # :nodoc:
-        connection_name_to_pool_manager.keys
-      end
-
-      # Returns the pools for a connection handler and given role. If +:all+ is passed,
-      # all pools belonging to the connection handler will be returned.
-      def connection_pool_list(role = nil)
-        if role.nil? || role == :all
-          connection_name_to_pool_manager.values.flat_map { |m| m.pool_configs.map(&:pool) }
-        else
-          connection_name_to_pool_manager.values.flat_map { |m| m.pool_configs(role).map(&:pool) }
-        end
-      end
-      alias :connection_pools :connection_pool_list
-
-      def each_connection_pool(role = nil, &block) # :nodoc:
-        role = nil if role == :all
-        return enum_for(__method__, role) unless block_given?
-
-        connection_name_to_pool_manager.each_value do |manager|
-          manager.each_pool_config(role) do |pool_config|
-            yield pool_config.pool
-          end
-        end
-      end
-
-      def establish_connection(config, owner_name: Base, role: Base.current_role, shard: Base.current_shard, clobber: false)
-        owner_name = determine_owner_name(owner_name, config)
-
-        pool_config = resolve_pool_config(config, owner_name, role, shard)
-        db_config = pool_config.db_config
-
-        pool_manager = set_pool_manager(pool_config.connection_descriptor)
-
-        # If there is an existing pool with the same values as the pool_config
-        # don't remove the connection. Connections should only be removed if we are
-        # establishing a connection on a class that is already connected to a different
-        # configuration.
-        existing_pool_config = pool_manager.get_pool_config(role, shard)
-
-        if !clobber && existing_pool_config && existing_pool_config.db_config == db_config
-          # Update the pool_config's connection class if it differs. This is used
-          # for ensuring that ActiveRecord::Base and the primary_abstract_class use
-          # the same pool. Without this granular swapping will not work correctly.
-          if owner_name.primary_class? && (existing_pool_config.connection_descriptor != owner_name)
-            existing_pool_config.connection_descriptor = owner_name
-          end
-
-          existing_pool_config.pool
-        else
-          disconnect_pool_from_pool_manager(pool_manager, role, shard)
-          pool_manager.set_pool_config(role, shard, pool_config)
-
-          payload = {
-            connection_name: pool_config.connection_descriptor.name,
-            role: role,
-            shard: shard,
-            config: db_config.configuration_hash
-          }
-
-          ActiveSupport::Notifications.instrumenter.instrument("!connection.active_record", payload) do
-            pool_config.pool
-          end
-        end
-      end
-
-      # Returns true if there are any active connections among the connection
-      # pools that the ConnectionHandler is managing.
-      def active_connections?(role = nil)
-        each_connection_pool(role).any?(&:active_connection?)
-      end
-
-      # Returns any connections in use by the current thread back to the pool,
-      # and also returns connections to the pool cached by threads that are no
-      # longer alive.
-      def clear_active_connections!(role = nil)
-        each_connection_pool(role).each do |pool|
-          pool.release_connection
-          pool.disable_query_cache!
-        end
-      end
-
-      # Clears reloadable connection caches in all connection pools.
-      #
-      # See ConnectionPool#clear_reloadable_connections! for details.
-      def clear_reloadable_connections!(role = nil)
-        each_connection_pool(role).each(&:clear_reloadable_connections!)
-      end
-
-      def clear_all_connections!(role = nil)
-        each_connection_pool(role).each(&:disconnect!)
-      end
-
-      # Disconnects all currently idle connections.
-      #
-      # See ConnectionPool#flush! for details.
-      def flush_idle_connections!(role = nil)
-        each_connection_pool(role).each(&:flush!)
-      end
-
-      # Locate the connection of the nearest super class. This can be an
-      # active or defined connection: if it is the latter, it will be
-      # opened and set as the active connection for the class it was defined
-      # for (not necessarily the current class).
-      def retrieve_connection(connection_name, role: ActiveRecord::Base.current_role, shard: ActiveRecord::Base.current_shard) # :nodoc:
-        pool = retrieve_connection_pool(connection_name, role: role, shard: shard, strict: true)
-        pool.lease_connection
-      end
-
-      # Returns true if a connection that's accessible to this class has
-      # already been opened.
-      def connected?(connection_name, role: ActiveRecord::Base.current_role, shard: ActiveRecord::Base.current_shard)
-        pool = retrieve_connection_pool(connection_name, role: role, shard: shard)
-        pool && pool.connected?
-      end
-
-      def remove_connection_pool(connection_name, role: ActiveRecord::Base.current_role, shard: ActiveRecord::Base.current_shard)
-        if pool_manager = get_pool_manager(connection_name)
-          disconnect_pool_from_pool_manager(pool_manager, role, shard)
-        end
-      end
-
-      # Retrieving the connection pool happens a lot, so we cache it in @connection_name_to_pool_manager.
-      # This makes retrieving the connection pool O(1) once the process is warm.
-      # When a connection is established or removed, we invalidate the cache.
-      def retrieve_connection_pool(connection_name, role: ActiveRecord::Base.current_role, shard: ActiveRecord::Base.current_shard, strict: false)
-        pool_manager = get_pool_manager(connection_name)
-        pool = pool_manager&.get_pool_config(role, shard)&.pool
-
-        if strict && !pool
-          selector = [
-            ("'#{shard}' shard" unless shard == ActiveRecord::Base.default_shard),
-            ("'#{role}' role" unless role == ActiveRecord::Base.default_role),
-          ].compact.join(" and ")
-
-          selector = [
-            (connection_name unless connection_name == "ActiveRecord::Base"),
-            selector.presence,
-          ].compact.join(" with ")
-
-          selector = " for #{selector}" if selector.present?
-
-          message = "No database connection defined#{selector}."
-
-          raise ConnectionNotDefined.new(message, connection_name: connection_name, shard: shard, role: role)
-        end
-
-        pool
-      end
-
-      private
-        attr_reader :connection_name_to_pool_manager
-
-        # Returns the pool manager for a connection name / identifier.
-        def get_pool_manager(connection_name)
-          connection_name_to_pool_manager[connection_name]
-        end
-
-        # Get the existing pool manager or initialize and assign a new one.
-        def set_pool_manager(connection_descriptor)
-          connection_name_to_pool_manager[connection_descriptor.name] ||= PoolManager.new
-        end
-
-        def pool_managers
-          connection_name_to_pool_manager.values
-        end
-
-        def disconnect_pool_from_pool_manager(pool_manager, role, shard)
-          pool_config = pool_manager.remove_pool_config(role, shard)
-
-          if pool_config
-            pool_config.disconnect!
-            pool_config.db_config
-          end
-        end
-
-        # Returns an instance of PoolConfig for a given adapter.
-        # Accepts a hash one layer deep that contains all connection information.
-        #
-        # == Example
-        #
-        #   config = { "production" => { "host" => "localhost", "database" => "foo", "adapter" => "sqlite3" } }
-        #   pool_config = Base.configurations.resolve_pool_config(:production)
-        #   pool_config.db_config.configuration_hash
-        #   # => { host: "localhost", database: "foo", adapter: "sqlite3" }
-        #
-        def resolve_pool_config(config, connection_name, role, shard)
-          db_config = Base.configurations.resolve(config)
-          db_config.validate!
-          raise(AdapterNotSpecified, "database configuration does not specify adapter") unless db_config.adapter
-          ConnectionAdapters::PoolConfig.new(connection_name, db_config, role, shard)
-        end
-
-        def determine_owner_name(owner_name, config)
-          if owner_name.is_a?(String) || owner_name.is_a?(Symbol)
-            ConnectionDescriptor.new(owner_name.to_s)
-          elsif config.is_a?(Symbol)
-            ConnectionDescriptor.new(config.to_s)
-          else
-            owner_name
-          end
-        end
-    end
-  end
-end