activerecord 6.0.4.7 → 6.1.7.3

data/lib/active_record/connection_adapters/connection_specification.rb

@@ -1,296 +0,0 @@
-# frozen_string_literal: true
-
-require "uri"
-
-module ActiveRecord
-  module ConnectionAdapters
-    class ConnectionSpecification #:nodoc:
-      attr_reader :name, :config, :adapter_method
-
-      def initialize(name, config, adapter_method)
-        @name, @config, @adapter_method = name, config, adapter_method
-      end
-
-      def initialize_dup(original)
-        @config = original.config.dup
-      end
-
-      def to_hash
-        @config.merge(name: @name)
-      end
-
-      # Expands a connection string into a hash.
-      class ConnectionUrlResolver # :nodoc:
-        # == Example
-        #
-        #   url = "postgresql://foo:bar@localhost:9000/foo_test?pool=5&timeout=3000"
-        #   ConnectionUrlResolver.new(url).to_hash
-        #   # => {
-        #     "adapter"  => "postgresql",
-        #     "host"     => "localhost",
-        #     "port"     => 9000,
-        #     "database" => "foo_test",
-        #     "username" => "foo",
-        #     "password" => "bar",
-        #     "pool"     => "5",
-        #     "timeout"  => "3000"
-        #   }
-        def initialize(url)
-          raise "Database URL cannot be empty" if url.blank?
-          @uri     = uri_parser.parse(url)
-          @adapter = @uri.scheme && @uri.scheme.tr("-", "_")
-          @adapter = "postgresql" if @adapter == "postgres"
-
-          if @uri.opaque
-            @uri.opaque, @query = @uri.opaque.split("?", 2)
-          else
-            @query = @uri.query
-          end
-        end
-
-        # Converts the given URL to a full connection hash.
-        def to_hash
-          config = raw_config.reject { |_, value| value.blank? }
-          config.map { |key, value| config[key] = uri_parser.unescape(value) if value.is_a? String }
-          config
-        end
-
-        private
-          attr_reader :uri
-
-          def uri_parser
-            @uri_parser ||= URI::Parser.new
-          end
-
-          # Converts the query parameters of the URI into a hash.
-          #
-          #   "localhost?pool=5&reaping_frequency=2"
-          #   # => { "pool" => "5", "reaping_frequency" => "2" }
-          #
-          # returns empty hash if no query present.
-          #
-          #   "localhost"
-          #   # => {}
-          def query_hash
-            Hash[(@query || "").split("&").map { |pair| pair.split("=", 2) }]
-          end
-
-          def raw_config
-            if uri.opaque
-              query_hash.merge(
-                "adapter"  => @adapter,
-                "database" => uri.opaque)
-            else
-              query_hash.merge(
-                "adapter"  => @adapter,
-                "username" => uri.user,
-                "password" => uri.password,
-                "port"     => uri.port,
-                "database" => database_from_path,
-                "host"     => uri.hostname)
-            end
-          end
-
-          # Returns name of the database.
-          def database_from_path
-            if @adapter == "sqlite3"
-              # 'sqlite3:/foo' is absolute, because that makes sense. The
-              # corresponding relative version, 'sqlite3:foo', is handled
-              # elsewhere, as an "opaque".
-
-              uri.path
-            else
-              # Only SQLite uses a filename as the "database" name; for
-              # anything else, a leading slash would be silly.
-
-              uri.path.sub(%r{^/}, "")
-            end
-          end
-      end
-
-      ##
-      # Builds a ConnectionSpecification from user input.
-      class Resolver # :nodoc:
-        attr_reader :configurations
-
-        # Accepts a list of db config objects.
-        def initialize(configurations)
-          @configurations = configurations
-        end
-
-        # Returns a hash with database connection information.
-        #
-        # == Examples
-        #
-        # Full hash Configuration.
-        #
-        #   configurations = { "production" => { "host" => "localhost", "database" => "foo", "adapter" => "sqlite3" } }
-        #   Resolver.new(configurations).resolve(:production)
-        #   # => { "host" => "localhost", "database" => "foo", "adapter" => "sqlite3"}
-        #
-        # Initialized with URL configuration strings.
-        #
-        #   configurations = { "production" => "postgresql://localhost/foo" }
-        #   Resolver.new(configurations).resolve(:production)
-        #   # => { "host" => "localhost", "database" => "foo", "adapter" => "postgresql" }
-        #
-        def resolve(config_or_env, pool_name = nil)
-          if config_or_env
-            resolve_connection config_or_env, pool_name
-          else
-            raise AdapterNotSpecified
-          end
-        end
-
-        # Returns an instance of ConnectionSpecification for a given adapter.
-        # Accepts a hash one layer deep that contains all connection information.
-        #
-        # == Example
-        #
-        #   config = { "production" => { "host" => "localhost", "database" => "foo", "adapter" => "sqlite3" } }
-        #   spec = Resolver.new(config).spec(:production)
-        #   spec.adapter_method
-        #   # => "sqlite3_connection"
-        #   spec.config
-        #   # => { "host" => "localhost", "database" => "foo", "adapter" => "sqlite3" }
-        #
-        def spec(config)
-          pool_name = config if config.is_a?(Symbol)
-
-          spec = resolve(config, pool_name).symbolize_keys
-
-          raise(AdapterNotSpecified, "database configuration does not specify adapter") unless spec.key?(:adapter)
-
-          # Require the adapter itself and give useful feedback about
-          #   1. Missing adapter gems and
-          #   2. Adapter gems' missing dependencies.
-          path_to_adapter = "active_record/connection_adapters/#{spec[:adapter]}_adapter"
-          begin
-            require path_to_adapter
-          rescue LoadError => e
-            # We couldn't require the adapter itself. Raise an exception that
-            # points out config typos and missing gems.
-            if e.path == path_to_adapter
-              # We can assume that a non-builtin adapter was specified, so it's
-              # either misspelled or missing from Gemfile.
-              raise LoadError, "Could not load the '#{spec[:adapter]}' Active Record adapter. Ensure that the adapter is spelled correctly in config/database.yml and that you've added the necessary adapter gem to your Gemfile.", e.backtrace
-
-            # Bubbled up from the adapter require. Prefix the exception message
-            # with some guidance about how to address it and reraise.
-            else
-              raise LoadError, "Error loading the '#{spec[:adapter]}' Active Record adapter. Missing a gem it depends on? #{e.message}", e.backtrace
-            end
-          end
-
-          adapter_method = "#{spec[:adapter]}_connection"
-
-          unless ActiveRecord::Base.respond_to?(adapter_method)
-            raise AdapterNotFound, "database configuration specifies nonexistent #{spec[:adapter]} adapter"
-          end
-
-          ConnectionSpecification.new(spec.delete(:name) || "primary", spec, adapter_method)
-        end
-
-        private
-          # Returns fully resolved connection, accepts hash, string or symbol.
-          # Always returns a hash.
-          #
-          # == Examples
-          #
-          # Symbol representing current environment.
-          #
-          #   Resolver.new("production" => {}).resolve_connection(:production)
-          #   # => {}
-          #
-          # One layer deep hash of connection values.
-          #
-          #   Resolver.new({}).resolve_connection("adapter" => "sqlite3")
-          #   # => { "adapter" => "sqlite3" }
-          #
-          # Connection URL.
-          #
-          #   Resolver.new({}).resolve_connection("postgresql://localhost/foo")
-          #   # => { "host" => "localhost", "database" => "foo", "adapter" => "postgresql" }
-          #
-          def resolve_connection(config_or_env, pool_name = nil)
-            case config_or_env
-            when Symbol
-              resolve_symbol_connection config_or_env, pool_name
-            when String
-              resolve_url_connection config_or_env
-            when Hash
-              resolve_hash_connection config_or_env
-            else
-              raise TypeError, "Invalid type for configuration. Expected Symbol, String, or Hash. Got #{config_or_env.inspect}"
-            end
-          end
-
-          # Takes the environment such as +:production+ or +:development+ and a
-          # pool name the corresponds to the name given by the connection pool
-          # to the connection. That pool name is merged into the hash with the
-          # name key.
-          #
-          # This requires that the @configurations was initialized with a key that
-          # matches.
-          #
-          #   configurations = #<ActiveRecord::DatabaseConfigurations:0x00007fd9fdace3e0
-          #     @configurations=[
-          #       #<ActiveRecord::DatabaseConfigurations::HashConfig:0x00007fd9fdace250
-          #         @env_name="production", @spec_name="primary", @config={"database"=>"my_db"}>
-          #       ]>
-          #
-          #   Resolver.new(configurations).resolve_symbol_connection(:production, "primary")
-          #   # => { "database" => "my_db" }
-          def resolve_symbol_connection(env_name, pool_name)
-            db_config = configurations.find_db_config(env_name)
-
-            if db_config
-              resolve_connection(db_config.config).merge("name" => pool_name.to_s)
-            else
-              raise AdapterNotSpecified, <<~MSG
-                The `#{env_name}` database is not configured for the `#{ActiveRecord::ConnectionHandling::DEFAULT_ENV.call}` environment.
-
-                Available databases configurations are:
-
-                #{build_configuration_sentence}
-              MSG
-            end
-          end
-
-          def build_configuration_sentence # :nodoc:
-            configs = configurations.configs_for(include_replicas: true)
-
-            configs.group_by(&:env_name).map do |env, config|
-              namespaces = config.map(&:spec_name)
-              if namespaces.size > 1
-                "#{env}: #{namespaces.join(", ")}"
-              else
-                env
-              end
-            end.join("\n")
-          end
-
-          # Accepts a hash. Expands the "url" key that contains a
-          # URL database connection to a full connection
-          # hash and merges with the rest of the hash.
-          # Connection details inside of the "url" key win any merge conflicts
-          def resolve_hash_connection(spec)
-            if spec["url"] && spec["url"] !~ /^jdbc:/
-              connection_hash = resolve_url_connection(spec.delete("url"))
-              spec.merge!(connection_hash)
-            end
-            spec
-          end
-
-          # Takes a connection URL.
-          #
-          #   Resolver.new({}).resolve_url_connection("postgresql://localhost/foo")
-          #   # => { "host" => "localhost", "database" => "foo", "adapter" => "postgresql" }
-          #
-          def resolve_url_connection(url)
-            ConnectionUrlResolver.new(url).to_hash
-          end
-      end
-    end
-  end
-end

data/lib/active_record/connection_adapters/determine_if_preparable_visitor.rb

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveRecord
-  module ConnectionAdapters
-    module DetermineIfPreparableVisitor
-      attr_accessor :preparable
-
-      def accept(object, collector)
-        @preparable = true
-        super
-      end
-
-      def visit_Arel_Nodes_In(o, collector)
-        @preparable = false
-        super
-      end
-
-      def visit_Arel_Nodes_NotIn(o, collector)
-        @preparable = false
-        super
-      end
-
-      def visit_Arel_Nodes_SqlLiteral(o, collector)
-        @preparable = false
-        super
-      end
-    end
-  end
-end

data/lib/active_record/define_callbacks.rb

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveRecord
-  # This module exists because ActiveRecord::AttributeMethods::Dirty needs to
-  # define callbacks, but continue to have its version of +save+ be the super
-  # method of ActiveRecord::Callbacks. This will be removed when the removal
-  # of deprecated code removes this need.
-  module DefineCallbacks
-    extend ActiveSupport::Concern
-
-    module ClassMethods # :nodoc:
-      include ActiveModel::Callbacks
-    end
-
-    included do
-      include ActiveModel::Validations::Callbacks
-
-      define_model_callbacks :initialize, :find, :touch, only: :after
-      define_model_callbacks :save, :create, :update, :destroy
-    end
-  end
-end

data/lib/active_record/railties/collection_cache_association_loading.rb

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveRecord
-  module Railties # :nodoc:
-    module CollectionCacheAssociationLoading #:nodoc:
-      def setup(context, options, as, block)
-        @relation = relation_from_options(**options)
-
-        super
-      end
-
-      def relation_from_options(cached: nil, partial: nil, collection: nil, **_)
-        return unless cached
-
-        relation = partial if partial.is_a?(ActiveRecord::Relation)
-        relation ||= collection if collection.is_a?(ActiveRecord::Relation)
-
-        if relation && !relation.loaded?
-          relation.skip_preloading!
-        end
-      end
-
-      def collection_without_template(*)
-        @relation.preload_associations(@collection) if @relation
-        super
-      end
-
-      def collection_with_template(*)
-        @relation.preload_associations(@collection) if @relation
-        super
-      end
-    end
-  end
-end

data/lib/active_record/relation/predicate_builder/base_handler.rb

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveRecord
-  class PredicateBuilder
-    class BaseHandler # :nodoc:
-      def initialize(predicate_builder)
-        @predicate_builder = predicate_builder
-      end
-
-      def call(attribute, value)
-        predicate_builder.build(attribute, value.id)
-      end
-
-      private
-        attr_reader :predicate_builder
-    end
-  end
-end

data/lib/active_record/relation/where_clause_factory.rb

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveRecord
-  class Relation
-    class WhereClauseFactory # :nodoc:
-      def initialize(klass, predicate_builder)
-        @klass = klass
-        @predicate_builder = predicate_builder
-      end
-
-      def build(opts, other)
-        case opts
-        when String, Array
-          parts = [klass.sanitize_sql(other.empty? ? opts : ([opts] + other))]
-        when Hash
-          attributes = predicate_builder.resolve_column_aliases(opts)
-          attributes.stringify_keys!
-
-          parts = predicate_builder.build_from_hash(attributes)
-        when Arel::Nodes::Node
-          parts = [opts]
-        else
-          raise ArgumentError, "Unsupported argument type: #{opts} (#{opts.class})"
-        end
-
-        WhereClause.new(parts)
-      end
-
-      private
-        attr_reader :klass, :predicate_builder
-    end
-  end
-end

data/lib/arel/attributes.rb

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-require "arel/attributes/attribute"
-
-module Arel # :nodoc: all
-  module Attributes
-    ###
-    # Factory method to wrap a raw database +column+ to an Arel Attribute.
-    def self.for(column)
-      case column.type
-      when :string, :text, :binary             then String
-      when :integer                            then Integer
-      when :float                              then Float
-      when :decimal                            then Decimal
-      when :date, :datetime, :timestamp, :time then Time
-      when :boolean                            then Boolean
-      else
-        Undefined
-      end
-    end
-  end
-end

data/lib/arel/visitors/depth_first.rb

@@ -1,203 +0,0 @@
-# frozen_string_literal: true
-
-module Arel # :nodoc: all
-  module Visitors
-    class DepthFirst < Arel::Visitors::Visitor
-      def initialize(block = nil)
-        @block = block || Proc.new
-        super()
-      end
-
-      private
-        def visit(o, _ = nil)
-          super
-          @block.call o
-        end
-
-        def unary(o)
-          visit o.expr
-        end
-        alias :visit_Arel_Nodes_Else              :unary
-        alias :visit_Arel_Nodes_Group             :unary
-        alias :visit_Arel_Nodes_Cube              :unary
-        alias :visit_Arel_Nodes_RollUp            :unary
-        alias :visit_Arel_Nodes_GroupingSet       :unary
-        alias :visit_Arel_Nodes_GroupingElement   :unary
-        alias :visit_Arel_Nodes_Grouping          :unary
-        alias :visit_Arel_Nodes_Having            :unary
-        alias :visit_Arel_Nodes_Lateral           :unary
-        alias :visit_Arel_Nodes_Limit             :unary
-        alias :visit_Arel_Nodes_Not               :unary
-        alias :visit_Arel_Nodes_Offset            :unary
-        alias :visit_Arel_Nodes_On                :unary
-        alias :visit_Arel_Nodes_Ordering          :unary
-        alias :visit_Arel_Nodes_Ascending         :unary
-        alias :visit_Arel_Nodes_Descending        :unary
-        alias :visit_Arel_Nodes_UnqualifiedColumn :unary
-        alias :visit_Arel_Nodes_OptimizerHints    :unary
-        alias :visit_Arel_Nodes_ValuesList        :unary
-
-        def function(o)
-          visit o.expressions
-          visit o.alias
-          visit o.distinct
-        end
-        alias :visit_Arel_Nodes_Avg    :function
-        alias :visit_Arel_Nodes_Exists :function
-        alias :visit_Arel_Nodes_Max    :function
-        alias :visit_Arel_Nodes_Min    :function
-        alias :visit_Arel_Nodes_Sum    :function
-
-        def visit_Arel_Nodes_NamedFunction(o)
-          visit o.name
-          visit o.expressions
-          visit o.distinct
-          visit o.alias
-        end
-
-        def visit_Arel_Nodes_Count(o)
-          visit o.expressions
-          visit o.alias
-          visit o.distinct
-        end
-
-        def visit_Arel_Nodes_Case(o)
-          visit o.case
-          visit o.conditions
-          visit o.default
-        end
-
-        def nary(o)
-          o.children.each { |child| visit child }
-        end
-        alias :visit_Arel_Nodes_And :nary
-
-        def binary(o)
-          visit o.left
-          visit o.right
-        end
-        alias :visit_Arel_Nodes_As                 :binary
-        alias :visit_Arel_Nodes_Assignment         :binary
-        alias :visit_Arel_Nodes_Between            :binary
-        alias :visit_Arel_Nodes_Concat             :binary
-        alias :visit_Arel_Nodes_DeleteStatement    :binary
-        alias :visit_Arel_Nodes_DoesNotMatch       :binary
-        alias :visit_Arel_Nodes_Equality           :binary
-        alias :visit_Arel_Nodes_FullOuterJoin      :binary
-        alias :visit_Arel_Nodes_GreaterThan        :binary
-        alias :visit_Arel_Nodes_GreaterThanOrEqual :binary
-        alias :visit_Arel_Nodes_In                 :binary
-        alias :visit_Arel_Nodes_InfixOperation     :binary
-        alias :visit_Arel_Nodes_JoinSource         :binary
-        alias :visit_Arel_Nodes_InnerJoin          :binary
-        alias :visit_Arel_Nodes_LessThan           :binary
-        alias :visit_Arel_Nodes_LessThanOrEqual    :binary
-        alias :visit_Arel_Nodes_Matches            :binary
-        alias :visit_Arel_Nodes_NotEqual           :binary
-        alias :visit_Arel_Nodes_NotIn              :binary
-        alias :visit_Arel_Nodes_NotRegexp          :binary
-        alias :visit_Arel_Nodes_IsNotDistinctFrom  :binary
-        alias :visit_Arel_Nodes_IsDistinctFrom     :binary
-        alias :visit_Arel_Nodes_Or                 :binary
-        alias :visit_Arel_Nodes_OuterJoin          :binary
-        alias :visit_Arel_Nodes_Regexp             :binary
-        alias :visit_Arel_Nodes_RightOuterJoin     :binary
-        alias :visit_Arel_Nodes_TableAlias         :binary
-        alias :visit_Arel_Nodes_When               :binary
-
-        def visit_Arel_Nodes_StringJoin(o)
-          visit o.left
-        end
-
-        def visit_Arel_Attribute(o)
-          visit o.relation
-          visit o.name
-        end
-        alias :visit_Arel_Attributes_Integer :visit_Arel_Attribute
-        alias :visit_Arel_Attributes_Float :visit_Arel_Attribute
-        alias :visit_Arel_Attributes_String :visit_Arel_Attribute
-        alias :visit_Arel_Attributes_Time :visit_Arel_Attribute
-        alias :visit_Arel_Attributes_Boolean :visit_Arel_Attribute
-        alias :visit_Arel_Attributes_Attribute :visit_Arel_Attribute
-        alias :visit_Arel_Attributes_Decimal :visit_Arel_Attribute
-
-        def visit_Arel_Table(o)
-          visit o.name
-        end
-
-        def terminal(o)
-        end
-        alias :visit_ActiveSupport_Multibyte_Chars :terminal
-        alias :visit_ActiveSupport_StringInquirer  :terminal
-        alias :visit_Arel_Nodes_Lock               :terminal
-        alias :visit_Arel_Nodes_Node               :terminal
-        alias :visit_Arel_Nodes_SqlLiteral         :terminal
-        alias :visit_Arel_Nodes_BindParam          :terminal
-        alias :visit_Arel_Nodes_Window             :terminal
-        alias :visit_Arel_Nodes_True               :terminal
-        alias :visit_Arel_Nodes_False              :terminal
-        alias :visit_BigDecimal                    :terminal
-        alias :visit_Class                         :terminal
-        alias :visit_Date                          :terminal
-        alias :visit_DateTime                      :terminal
-        alias :visit_FalseClass                    :terminal
-        alias :visit_Float                         :terminal
-        alias :visit_Integer                       :terminal
-        alias :visit_NilClass                      :terminal
-        alias :visit_String                        :terminal
-        alias :visit_Symbol                        :terminal
-        alias :visit_Time                          :terminal
-        alias :visit_TrueClass                     :terminal
-
-        def visit_Arel_Nodes_InsertStatement(o)
-          visit o.relation
-          visit o.columns
-          visit o.values
-        end
-
-        def visit_Arel_Nodes_SelectCore(o)
-          visit o.projections
-          visit o.source
-          visit o.wheres
-          visit o.groups
-          visit o.windows
-          visit o.havings
-        end
-
-        def visit_Arel_Nodes_SelectStatement(o)
-          visit o.cores
-          visit o.orders
-          visit o.limit
-          visit o.lock
-          visit o.offset
-        end
-
-        def visit_Arel_Nodes_UpdateStatement(o)
-          visit o.relation
-          visit o.values
-          visit o.wheres
-          visit o.orders
-          visit o.limit
-        end
-
-        def visit_Arel_Nodes_Comment(o)
-          visit o.values
-        end
-
-        def visit_Array(o)
-          o.each { |i| visit i }
-        end
-        alias :visit_Set :visit_Array
-
-        def visit_Hash(o)
-          o.each { |k, v| visit(k); visit(v) }
-        end
-
-        DISPATCH = dispatch_cache
-
-        def get_dispatch_cache
-          DISPATCH
-        end
-    end
-  end
-end

data/lib/arel/visitors/ibm_db.rb

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-
-module Arel # :nodoc: all
-  module Visitors
-    class IBM_DB < Arel::Visitors::ToSql
-      private
-        def visit_Arel_Nodes_SelectCore(o, collector)
-          collector = super
-          maybe_visit o.optimizer_hints, collector
-        end
-
-        def visit_Arel_Nodes_OptimizerHints(o, collector)
-          hints = o.expr.map { |v| sanitize_as_sql_comment(v) }.join
-          collector << "/* <OPTGUIDELINES>#{hints}</OPTGUIDELINES> */"
-        end
-
-        def visit_Arel_Nodes_Limit(o, collector)
-          collector << "FETCH FIRST "
-          collector = visit o.expr, collector
-          collector << " ROWS ONLY"
-        end
-
-        def is_distinct_from(o, collector)
-          collector << "DECODE("
-          collector = visit [o.left, o.right, 0, 1], collector
-          collector << ")"
-        end
-
-        def collect_optimizer_hints(o, collector)
-          collector
-        end
-    end
-  end
-end