activerecord 3.2.22.5 → 4.2.11.3

data/lib/active_record/associations/preloader/has_and_belongs_to_many.rb

@@ -1,60 +0,0 @@
-module ActiveRecord
-  module Associations
-    class Preloader
-      class HasAndBelongsToMany < CollectionAssociation #:nodoc:
-        attr_reader :join_table
-
-        def initialize(klass, records, reflection, preload_options)
-          super
-          @join_table = Arel::Table.new(options[:join_table]).alias('t0')
-        end
-
-        # Unlike the other associations, we want to get a raw array of rows so that we can
-        # access the aliased column on the join table
-        def records_for(ids)
-          scope = super
-          klass.connection.select_all(scope.arel, 'SQL', scope.bind_values)
-        end
-
-        def owner_key_name
-          reflection.active_record_primary_key
-        end
-
-        def association_key_name
-          'ar_association_key_name'
-        end
-
-        def association_key
-          join_table[reflection.foreign_key]
-        end
-
-        private
-
-        # Once we have used the join table column (in super), we manually instantiate the
-        # actual records, ensuring that we don't create more than one instances of the same
-        # record
-        def associated_records_by_owner
-          records = {}
-          super.each do |owner_key, rows|
-            rows.map! { |row| records[row[klass.primary_key]] ||= klass.instantiate(row) }
-          end
-        end
-
-        def build_scope
-          super.joins(join).select(join_select)
-        end
-
-        def join_select
-          association_key.as(Arel.sql(association_key_name))
-        end
-
-        def join
-          condition = table[reflection.association_primary_key].eq(
-            join_table[reflection.association_foreign_key])
-
-          table.create_join(join_table, table.create_on(condition))
-        end
-      end
-    end
-  end
-end

data/lib/active_record/attribute_methods/deprecated_underscore_read.rb

@@ -1,32 +0,0 @@
-require 'active_support/concern'
-require 'active_support/deprecation'
-
-module ActiveRecord
-  module AttributeMethods
-    module DeprecatedUnderscoreRead
-      extend ActiveSupport::Concern
-
-      included do
-        attribute_method_prefix "_"
-      end
-
-      module ClassMethods
-        protected
-
-        def define_method__attribute(attr_name)
-          # Do nothing, let it hit method missing instead.
-        end
-      end
-
-      protected
-
-      def _attribute(attr_name)
-        ActiveSupport::Deprecation.warn(
-          "You have called '_#{attr_name}'. This is deprecated. Please use " \
-          "either '#{attr_name}' or read_attribute('#{attr_name}')."
-        )
-        read_attribute(attr_name)
-      end
-    end
-  end
-end

data/lib/active_record/connection_adapters/abstract/connection_specification.rb

@@ -1,191 +0,0 @@
-require 'uri'
-
-module ActiveRecord
-  class Base
-    class ConnectionSpecification #:nodoc:
-      attr_reader :config, :adapter_method
-      def initialize (config, adapter_method)
-        @config, @adapter_method = config, adapter_method
-      end
-
-      ##
-      # Builds a ConnectionSpecification from user input
-      class Resolver # :nodoc:
-        attr_reader :config, :klass, :configurations
-
-        def initialize(config, configurations)
-          @config         = config
-          @configurations = configurations
-        end
-
-        def spec
-          case config
-          when nil
-            raise AdapterNotSpecified unless defined?(Rails.env)
-            resolve_string_connection Rails.env
-          when Symbol, String
-            resolve_string_connection config.to_s
-          when Hash
-            resolve_hash_connection config
-          end
-        end
-
-        private
-        def resolve_string_connection(spec) # :nodoc:
-          hash = configurations.fetch(spec) do |k|
-            connection_url_to_hash(k)
-          end
-
-          raise(AdapterNotSpecified, "#{spec} database is not configured") unless hash
-
-          resolve_hash_connection hash
-        end
-
-        def resolve_hash_connection(spec) # :nodoc:
-          spec = spec.symbolize_keys
-
-          raise(AdapterNotSpecified, "database configuration does not specify adapter") unless spec.key?(:adapter)
-
-          begin
-            require "active_record/connection_adapters/#{spec[:adapter]}_adapter"
-          rescue LoadError => e
-            raise LoadError, "Please install the #{spec[:adapter]} adapter: `gem install activerecord-#{spec[:adapter]}-adapter` (#{e.message})", e.backtrace
-          end
-
-          adapter_method = "#{spec[:adapter]}_connection"
-
-          ConnectionSpecification.new(spec, adapter_method)
-        end
-
-        def connection_url_to_hash(url) # :nodoc:
-          config = URI.parse url
-          adapter = config.scheme
-          adapter = "postgresql" if adapter == "postgres"
-          spec = { :adapter  => adapter,
-                   :username => config.user,
-                   :password => config.password,
-                   :port     => config.port,
-                   :database => config.path.sub(%r{^/},""),
-                   :host     => config.host }
-          spec.reject!{ |_,value| value.blank? }
-          spec.map { |key,value| spec[key] = URI.unescape(value) if value.is_a?(String) }
-          if config.query
-            options = Hash[config.query.split("&").map{ |pair| pair.split("=") }].symbolize_keys
-            spec.merge!(options)
-          end
-          spec
-        end
-      end
-    end
-
-    ##
-    # :singleton-method:
-    # The connection handler
-    class_attribute :connection_handler, :instance_writer => false
-    self.connection_handler = ConnectionAdapters::ConnectionHandler.new
-
-    # Returns the connection currently associated with the class. This can
-    # also be used to "borrow" the connection to do database work that isn't
-    # easily done without going straight to SQL.
-    def connection
-      self.class.connection
-    end
-
-    # Establishes the connection to the database. Accepts a hash as input where
-    # the <tt>:adapter</tt> key must be specified with the name of a database adapter (in lower-case)
-    # example for regular databases (MySQL, Postgresql, etc):
-    #
-    #   ActiveRecord::Base.establish_connection(
-    #     :adapter  => "mysql",
-    #     :host     => "localhost",
-    #     :username => "myuser",
-    #     :password => "mypass",
-    #     :database => "somedatabase"
-    #   )
-    #
-    # Example for SQLite database:
-    #
-    #   ActiveRecord::Base.establish_connection(
-    #     :adapter => "sqlite",
-    #     :database  => "path/to/dbfile"
-    #   )
-    #
-    # Also accepts keys as strings (for parsing from YAML for example):
-    #
-    #   ActiveRecord::Base.establish_connection(
-    #     "adapter" => "sqlite",
-    #     "database"  => "path/to/dbfile"
-    #   )
-    #
-    # Or a URL:
-    #
-    #   ActiveRecord::Base.establish_connection(
-    #     "postgres://myuser:mypass@localhost/somedatabase"
-    #   )
-    #
-    # The exceptions AdapterNotSpecified, AdapterNotFound and ArgumentError
-    # may be returned on an error.
-    def self.establish_connection(spec = ENV["DATABASE_URL"])
-      resolver = ConnectionSpecification::Resolver.new spec, configurations
-      spec = resolver.spec
-
-      unless respond_to?(spec.adapter_method)
-        raise AdapterNotFound, "database configuration specifies nonexistent #{spec.config[:adapter]} adapter"
-      end
-
-      remove_connection
-      connection_handler.establish_connection name, spec
-    end
-
-    class << self
-      # Returns the connection currently associated with the class. This can
-      # also be used to "borrow" the connection to do database work unrelated
-      # to any of the specific Active Records.
-      def connection
-        retrieve_connection
-      end
-
-      def connection_id
-        Thread.current['ActiveRecord::Base.connection_id']
-      end
-
-      def connection_id=(connection_id)
-        Thread.current['ActiveRecord::Base.connection_id'] = connection_id
-      end
-
-      # Returns the configuration of the associated connection as a hash:
-      #
-      #  ActiveRecord::Base.connection_config
-      #  # => {:pool=>5, :timeout=>5000, :database=>"db/development.sqlite3", :adapter=>"sqlite3"}
-      #
-      # Please use only for reading.
-      def connection_config
-        connection_pool.spec.config
-      end
-
-      def connection_pool
-        connection_handler.retrieve_connection_pool(self) or raise ConnectionNotEstablished
-      end
-
-      def retrieve_connection
-        connection_handler.retrieve_connection(self)
-      end
-
-      # Returns true if Active Record is connected.
-      def connected?
-        connection_handler.connected?(self)
-      end
-
-      def remove_connection(klass = self)
-        connection_handler.remove_connection(klass)
-      end
-
-      def clear_active_connections!
-        connection_handler.clear_active_connections!
-      end
-
-      delegate :clear_reloadable_connections!,
-        :clear_all_connections!,:verify_active_connections!, :to => :connection_handler
-    end
-  end
-end