activerecord 3.2.6 → 6.0.0

data/lib/active_record/associations/join_helper.rb

@@ -1,55 +0,0 @@
-module ActiveRecord
-  module Associations
-    # Helper class module which gets mixed into JoinDependency::JoinAssociation and AssociationScope
-    module JoinHelper #:nodoc:
-
-      def join_type
-        Arel::InnerJoin
-      end
-
-      private
-
-      def construct_tables
-        tables = []
-        chain.each do |reflection|
-          tables << alias_tracker.aliased_table_for(
-            table_name_for(reflection),
-            table_alias_for(reflection, reflection != self.reflection)
-          )
-
-          if reflection.source_macro == :has_and_belongs_to_many
-            tables << alias_tracker.aliased_table_for(
-              (reflection.source_reflection || reflection).options[:join_table],
-              table_alias_for(reflection, true)
-            )
-          end
-        end
-        tables
-      end
-
-      def table_name_for(reflection)
-        reflection.table_name
-      end
-
-      def table_alias_for(reflection, join = false)
-        name = "#{reflection.plural_name}_#{alias_suffix}"
-        name << "_join" if join
-        name
-      end
-
-      def join(table, constraint)
-        table.create_join(table, table.create_on(constraint), join_type)
-      end
-
-      def sanitize(conditions, table)
-        conditions = conditions.map do |condition|
-          condition = active_record.send(:sanitize_sql, interpolate(condition), table.table_alias || table.name)
-          condition = Arel.sql(condition) unless condition.is_a?(Arel::Node)
-          condition
-        end
-
-        conditions.length == 1 ? conditions.first : Arel::Nodes::And.new(conditions)
-      end
-    end
-  end
-end

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

@@ -1,17 +0,0 @@
-module ActiveRecord
-  module Associations
-    class Preloader
-      class BelongsTo < SingularAssociation #:nodoc:
-
-        def association_key_name
-          reflection.options[:primary_key] || klass && klass.primary_key
-        end
-
-        def owner_key_name
-          reflection.foreign_key
-        end
-
-      end
-    end
-  end
-end

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

@@ -1,24 +0,0 @@
-module ActiveRecord
-  module Associations
-    class Preloader
-      class CollectionAssociation < Association #:nodoc:
-
-        private
-
-        def build_scope
-          super.order(preload_options[:order] || options[:order])
-        end
-
-        def preload
-          associated_records_by_owner.each do |owner, records|
-            association = owner.association(reflection.name)
-            association.loaded!
-            association.target.concat(records)
-            records.each { |record| association.set_inverse_instance(record) }
-          end
-        end
-
-      end
-    end
-  end
-end

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/associations/preloader/has_many.rb

@@ -1,17 +0,0 @@
-module ActiveRecord
-  module Associations
-    class Preloader
-      class HasMany < CollectionAssociation #:nodoc:
-
-        def association_key_name
-          reflection.foreign_key
-        end
-
-        def owner_key_name
-          reflection.active_record_primary_key
-        end
-
-      end
-    end
-  end
-end

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

@@ -1,15 +0,0 @@
-module ActiveRecord
-  module Associations
-    class Preloader
-      class HasManyThrough < CollectionAssociation #:nodoc:
-        include ThroughAssociation
-
-        def associated_records_by_owner
-          super.each do |owner, records|
-            records.uniq! if options[:uniq]
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,23 +0,0 @@
-module ActiveRecord
-  module Associations
-    class Preloader
-      class HasOne < SingularAssociation #:nodoc:
-
-        def association_key_name
-          reflection.foreign_key
-        end
-
-        def owner_key_name
-          reflection.active_record_primary_key
-        end
-
-        private
-
-        def build_scope
-          super.order(preload_options[:order] || options[:order])
-        end
-
-      end
-    end
-  end
-end

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

@@ -1,9 +0,0 @@
-module ActiveRecord
-  module Associations
-    class Preloader
-      class HasOneThrough < SingularAssociation #:nodoc:
-        include ThroughAssociation
-      end
-    end
-  end
-end

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

@@ -1,21 +0,0 @@
-module ActiveRecord
-  module Associations
-    class Preloader
-      class SingularAssociation < Association #:nodoc:
-
-        private
-
-        def preload
-          associated_records_by_owner.each do |owner, associated_records|
-            record = associated_records.first
-
-            association = owner.association(reflection.name)
-            association.target = record
-            association.set_inverse_instance(record)
-          end
-        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,188 +0,0 @@
-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 }
-          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