s/specification_id/specification_name

activerecord/lib/active_record/connection_adapters/abstract/connection_pool.rb

@@ -837,7 +837,7 @@ def connection_pool_list
       alias :connection_pools :connection_pool_list
 
       def establish_connection(spec)
-        owner_to_pool[spec.id] = ConnectionAdapters::ConnectionPool.new(spec)
+        owner_to_pool[spec.name] = ConnectionAdapters::ConnectionPool.new(spec)
       end
 
       # Returns true if there are any active connections among the connection
@@ -868,27 +868,27 @@ def clear_all_connections!
       # 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(spec_id) #:nodoc:
-        pool = retrieve_connection_pool(spec_id)
-        raise ConnectionNotEstablished, "No connection pool with id #{spec_id} found." unless pool
+      def retrieve_connection(spec_name) #:nodoc:
+        pool = retrieve_connection_pool(spec_name)
+        raise ConnectionNotEstablished, "No connection pool with id #{spec_name} found." unless pool
         conn = pool.connection
-        raise ConnectionNotEstablished, "No connection for #{spec_id} in connection pool" unless conn
+        raise ConnectionNotEstablished, "No connection for #{spec_name} in connection pool" unless conn
         conn
       end
 
       # Returns true if a connection that's accessible to this class has
       # already been opened.
-      def connected?(spec_id)
-        conn = retrieve_connection_pool(spec_id)
+      def connected?(spec_name)
+        conn = retrieve_connection_pool(spec_name)
         conn && conn.connected?
       end
 
       # Remove the connection for this class. This will close the active
       # connection and the defined connection (if they exist). The result
       # can be used as an argument for establish_connection, for easily
       # re-establishing the connection.
-      def remove_connection(spec_id)
-        if pool = owner_to_pool.delete(spec_id)
+      def remove_connection(spec_name)
+        if pool = owner_to_pool.delete(spec_name)
           pool.automatic_reconnect = false
           pool.disconnect!
           pool.spec.config
@@ -904,17 +904,17 @@ def remove_connection(spec_id)
       # #fetch is significantly slower than #[]. So in the nil case, no caching will
       # take place, but that's ok since the nil case is not the common one that we wish
       # to optimise for.
-      def retrieve_connection_pool(spec_id)
-        owner_to_pool.fetch(spec_id) do
-          if ancestor_pool = pool_from_any_process_for(spec_id)
+      def retrieve_connection_pool(spec_name)
+        owner_to_pool.fetch(spec_name) do
+          if ancestor_pool = pool_from_any_process_for(spec_name)
             # A connection was established in an ancestor process that must have
             # subsequently forked. We can't reuse the connection, but we can copy
             # the specification and establish a new connection with it.
             establish_connection(ancestor_pool.spec).tap do |pool|
               pool.schema_cache = ancestor_pool.schema_cache if ancestor_pool.schema_cache
             end
           else
-            owner_to_pool[spec_id] = nil
+            owner_to_pool[spec_name] = nil
           end
         end
       end
@@ -925,9 +925,9 @@ def owner_to_pool
         @owner_to_pool[Process.pid]
       end
 
-      def pool_from_any_process_for(spec_id)
-        owner_to_pool = @owner_to_pool.values.find { |v| v[spec_id] }
-        owner_to_pool && owner_to_pool[spec_id]
+      def pool_from_any_process_for(spec_name)
+        owner_to_pool = @owner_to_pool.values.find { |v| v[spec_name] }
+        owner_to_pool && owner_to_pool[spec_name]
       end
     end
   end

activerecord/lib/active_record/connection_adapters/connection_specification.rb

@@ -3,10 +3,10 @@
 module ActiveRecord
   module ConnectionAdapters
     class ConnectionSpecification #:nodoc:
-      attr_reader :config, :adapter_method, :id
+      attr_reader :name, :config, :adapter_method
 
-      def initialize(id, config, adapter_method)
-        @id, @config, @adapter_method = id, config, adapter_method
+      def initialize(name, config, adapter_method)
+        @name, @config, @adapter_method = name, config, adapter_method
       end
 
       def initialize_dup(original)
@@ -164,7 +164,7 @@ def resolve_all
         #   spec.config
         #   # => { "host" => "localhost", "database" => "foo", "adapter" => "sqlite3" }
         #
-        def spec(config, id = nil)
+        def spec(config, name = nil)
           spec = resolve(config).symbolize_keys
 
           raise(AdapterNotSpecified, "database configuration does not specify adapter") unless spec.key?(:adapter)
@@ -180,13 +180,13 @@ def spec(config, id = nil)
 
           adapter_method = "#{spec[:adapter]}_connection"
 
-          id ||=
+          name ||=
             if config.is_a?(Symbol)
               config.to_s
             else
               "primary"
             end
-          ConnectionSpecification.new(id, spec, adapter_method)
+          ConnectionSpecification.new(name, spec, adapter_method)
         end
 
         private

activerecord/lib/active_record/connection_handling.rb

@@ -51,7 +51,7 @@ def establish_connection(spec = nil)
       resolver =   ConnectionAdapters::ConnectionSpecification::Resolver.new configurations
       # TODO: uses name on establish_connection, for backwards compatibility
       spec     =   resolver.spec(spec, self == Base ? "primary" : name)
-      self.specification_id = spec.id
+      self.specification_name = spec.name
 
       unless respond_to?(spec.adapter_method)
         raise AdapterNotFound, "database configuration specifies nonexistent #{spec.config[:adapter]} adapter"
@@ -91,15 +91,15 @@ def connection
       retrieve_connection
     end
 
-    attr_writer :specification_id
+    attr_writer :specification_name
 
     # Return the specification id from this class otherwise look it up
     # in the parent.
-    def specification_id
-      unless defined?(@specification_id)
-        @specification_id = self == Base ? "primary" : superclass.specification_id
+    def specification_name
+      unless defined?(@specification_name)
+        @specification_name = self == Base ? "primary" : superclass.specification_name
       end
-      @specification_id
+      @specification_name
     end
 
     def connection_id
@@ -121,20 +121,20 @@ def connection_config
     end
 
     def connection_pool
-      connection_handler.retrieve_connection_pool(specification_id) or raise ConnectionNotEstablished
+      connection_handler.retrieve_connection_pool(specification_name) or raise ConnectionNotEstablished
     end
 
     def retrieve_connection
-      connection_handler.retrieve_connection(specification_id)
+      connection_handler.retrieve_connection(specification_name)
     end
 
     # Returns +true+ if Active Record is connected.
     def connected?
-      connection_handler.connected?(specification_id)
+      connection_handler.connected?(specification_name)
     end
 
-    def remove_connection(id = specification_id)
-      connection_handler.remove_connection(id)
+    def remove_connection(name = specification_name)
+      connection_handler.remove_connection(name)
     end
 
     def clear_cache! # :nodoc:

activerecord/lib/active_record/core.rb

@@ -257,7 +257,7 @@ def arel_table # :nodoc:
       # Returns the Arel engine.
       def arel_engine # :nodoc:
         @arel_engine ||=
-          if Base == self || connection_handler.retrieve_connection_pool(specification_id)
+          if Base == self || connection_handler.retrieve_connection_pool(specification_name)
             self
           else
             superclass.arel_engine

activerecord/lib/active_record/tasks/database_tasks.rb

@@ -117,7 +117,7 @@ def create(*arguments)
       end
 
       def create_all
-        old_pool = ActiveRecord::Base.connection_handler.retrieve_connection_pool(ActiveRecord::Base.specification_id)
+        old_pool = ActiveRecord::Base.connection_handler.retrieve_connection_pool(ActiveRecord::Base.specification_name)
         each_local_configuration { |configuration| create configuration }
         if old_pool
           ActiveRecord::Base.connection_handler.establish_connection(old_pool.spec)

activerecord/test/cases/connection_adapters/connection_handler_test.rb

@@ -6,11 +6,11 @@ class ConnectionHandlerTest < ActiveRecord::TestCase
       def setup
         @handler = ConnectionHandler.new
         resolver = ConnectionAdapters::ConnectionSpecification::Resolver.new Base.configurations
-        @spec_id = "primary"
-        @pool    = @handler.establish_connection(resolver.spec(:arunit, @spec_id))
+        @spec_name = "primary"
+        @pool    = @handler.establish_connection(resolver.spec(:arunit, @spec_name))
       end
 
-      def test_establish_connection_uses_spec_id
+      def test_establish_connection_uses_spec_name
         config = {"readonly" => {"adapter" => 'sqlite3'}}
         resolver = ConnectionAdapters::ConnectionSpecification::Resolver.new(config)
         spec =   resolver.spec(:readonly)
@@ -22,19 +22,19 @@ def test_establish_connection_uses_spec_id
       end
 
       def test_retrieve_connection
-        assert @handler.retrieve_connection(@spec_id)
+        assert @handler.retrieve_connection(@spec_name)
       end
 
       def test_active_connections?
         assert !@handler.active_connections?
-        assert @handler.retrieve_connection(@spec_id)
+        assert @handler.retrieve_connection(@spec_name)
         assert @handler.active_connections?
         @handler.clear_active_connections!
         assert !@handler.active_connections?
       end
 
       def test_retrieve_connection_pool
-        assert_not_nil @handler.retrieve_connection_pool(@spec_id)
+        assert_not_nil @handler.retrieve_connection_pool(@spec_name)
       end
 
       def test_retrieve_connection_pool_with_invalid_id
@@ -77,7 +77,7 @@ def test_retrieve_connection_pool_copies_schema_cache_from_ancestor_pool
 
           pid = fork {
             rd.close
-            pool = @handler.retrieve_connection_pool(@spec_id)
+            pool = @handler.retrieve_connection_pool(@spec_name)
             wr.write Marshal.dump pool.schema_cache.size
             wr.close
             exit!

activerecord/test/cases/connection_specification/resolver_test.rb

@@ -116,14 +116,14 @@ def test_url_sub_key_for_sqlite3
             "encoding" => "utf8" }, spec)
         end
 
-        def test_spec_id_on_key_lookup
+        def test_spec_name_on_key_lookup
           spec = spec(:readonly, 'readonly' => {'adapter' => 'sqlite3'})
-          assert_equal "readonly", spec.id
+          assert_equal "readonly", spec.name
         end
 
-        def test_spec_id_with_inline_config
+        def test_spec_name_with_inline_config
           spec = spec({'adapter' => 'sqlite3'})
-          assert_equal "primary", spec.id, "should default to primary id"
+          assert_equal "primary", spec.name, "should default to primary id"
         end
       end
     end

activerecord/test/cases/multiple_db_test.rb

@@ -25,10 +25,10 @@ def test_proper_connection
   end
 
   def test_swapping_the_connection
-    old_spec_id, Course.specification_id = Course.specification_id, "primary"
+    old_spec_name, Course.specification_name = Course.specification_name, "primary"
     assert_equal(Entrant.connection, Course.connection)
   ensure
-    Course.specification_id = old_spec_id
+    Course.specification_name = old_spec_name
   end
 
   def test_find