activerecord 5.0.7.2 → 6.1.1

data/lib/active_record/attribute_set.rb

@@ -1,110 +0,0 @@
-require 'active_record/attribute_set/builder'
-
-module ActiveRecord
-  class AttributeSet # :nodoc:
-    delegate :fetch, :except, to: :attributes
-
-    def initialize(attributes)
-      @attributes = attributes
-    end
-
-    def [](name)
-      attributes[name] || Attribute.null(name)
-    end
-
-    def []=(name, value)
-      attributes[name] = value
-    end
-
-    def values_before_type_cast
-      attributes.transform_values(&:value_before_type_cast)
-    end
-
-    def to_hash
-      initialized_attributes.transform_values(&:value)
-    end
-    alias_method :to_h, :to_hash
-
-    def key?(name)
-      attributes.key?(name) && self[name].initialized?
-    end
-
-    def keys
-      attributes.each_key.select { |name| self[name].initialized? }
-    end
-
-    if defined?(JRUBY_VERSION)
-      # This form is significantly faster on JRuby, and this is one of our biggest hotspots.
-      # https://github.com/jruby/jruby/pull/2562
-      def fetch_value(name, &block)
-        self[name].value(&block)
-      end
-    else
-      def fetch_value(name)
-        self[name].value { |n| yield n if block_given? }
-      end
-    end
-
-    def write_from_database(name, value)
-      attributes[name] = self[name].with_value_from_database(value)
-    end
-
-    def write_from_user(name, value)
-      attributes[name] = self[name].with_value_from_user(value)
-    end
-
-    def write_cast_value(name, value)
-      attributes[name] = self[name].with_cast_value(value)
-    end
-
-    def freeze
-      @attributes.freeze
-      super
-    end
-
-    def deep_dup
-      dup.tap do |copy|
-        copy.instance_variable_set(:@attributes, attributes.deep_dup)
-      end
-    end
-
-    def initialize_dup(_)
-      @attributes = attributes.dup
-      super
-    end
-
-    def initialize_clone(_)
-      @attributes = attributes.clone
-      super
-    end
-
-    def reset(key)
-      if key?(key)
-        write_from_database(key, nil)
-      end
-    end
-
-    def accessed
-      attributes.select { |_, attr| attr.has_been_read? }.keys
-    end
-
-    def map(&block)
-      new_attributes = attributes.transform_values(&block)
-      AttributeSet.new(new_attributes)
-    end
-
-    def ==(other)
-      attributes == other.attributes
-    end
-
-    protected
-
-    attr_reader :attributes
-
-    private
-
-    def initialized_attributes
-      attributes.select { |_, attr| attr.initialized? }
-    end
-  end
-end

data/lib/active_record/attribute_set/builder.rb

@@ -1,132 +0,0 @@
-require 'active_record/attribute'
-
-module ActiveRecord
-  class AttributeSet # :nodoc:
-    class Builder # :nodoc:
-      attr_reader :types, :default_attributes
-
-      def initialize(types, default_attributes = {})
-        @types = types
-        @default_attributes = default_attributes
-      end
-
-      def build_from_database(values = {}, additional_types = {})
-        attributes = LazyAttributeHash.new(types, values, additional_types, default_attributes)
-        AttributeSet.new(attributes)
-      end
-    end
-  end
-
-  class LazyAttributeHash # :nodoc:
-    delegate :transform_values, :each_key, :fetch, :except, to: :materialize
-
-    def initialize(types, values, additional_types, default_attributes, delegate_hash = {})
-      @types = types
-      @values = values
-      @additional_types = additional_types
-      @materialized = false
-      @delegate_hash = delegate_hash
-      @default_attributes = default_attributes
-    end
-
-    def key?(key)
-      delegate_hash.key?(key) || values.key?(key) || types.key?(key)
-    end
-
-    def [](key)
-      delegate_hash[key] || assign_default_value(key)
-    end
-
-    def []=(key, value)
-      if frozen?
-        raise RuntimeError, "Can't modify frozen hash"
-      end
-      delegate_hash[key] = value
-    end
-
-    def deep_dup
-      dup.tap do |copy|
-        copy.instance_variable_set(:@delegate_hash, delegate_hash.transform_values(&:dup))
-      end
-    end
-
-    def initialize_dup(_)
-      @delegate_hash = Hash[delegate_hash]
-      super
-    end
-
-    def select
-      keys = types.keys | values.keys | delegate_hash.keys
-      keys.each_with_object({}) do |key, hash|
-        attribute = self[key]
-        if yield(key, attribute)
-          hash[key] = attribute
-        end
-      end
-    end
-
-    def ==(other)
-      if other.is_a?(LazyAttributeHash)
-        materialize == other.materialize
-      else
-        materialize == other
-      end
-    end
-
-    def marshal_dump
-      [@types, @values, @additional_types, @default_attributes, @delegate_hash]
-    end
-
-    def marshal_load(values)
-      if values.is_a?(Hash)
-        empty_hash = {}.freeze
-        initialize(empty_hash, empty_hash, empty_hash, empty_hash, values)
-        @materialized = true
-      else
-        initialize(*values)
-      end
-    end
-
-    def encode_with(coder)
-      coder["delegate_hash"] = materialize
-    end
-
-    def init_with(coder)
-      marshal_load(coder["delegate_hash"])
-    end
-
-    protected
-
-    attr_reader :types, :values, :additional_types, :delegate_hash, :default_attributes
-
-    def materialize
-      unless @materialized
-        values.each_key { |key| self[key] }
-        types.each_key { |key| self[key] }
-        unless frozen?
-          @materialized = true
-        end
-      end
-      delegate_hash
-    end
-
-    private
-
-    def assign_default_value(name)
-      type = additional_types.fetch(name, types[name])
-      value_present = true
-      value = values.fetch(name) { value_present = false }
-
-      if value_present
-        delegate_hash[name] = Attribute.from_database(name, value, type)
-      elsif types.key?(name)
-        attr = default_attributes[name]
-        if attr
-          delegate_hash[name] = attr.dup
-        else
-          delegate_hash[name] = Attribute.uninitialized(name, type)
-        end
-      end
-    end
-  end
-end

data/lib/active_record/collection_cache_key.rb

@@ -1,50 +0,0 @@
-module ActiveRecord
-  module CollectionCacheKey
-
-    def collection_cache_key(collection = all, timestamp_column = :updated_at) # :nodoc:
-      query_signature = Digest::MD5.hexdigest(collection.to_sql)
-      key = "#{collection.model_name.cache_key}/query-#{query_signature}"
-
-      if collection.loaded?
-        size = collection.size
-        if size > 0
-          timestamp = collection.max_by(&timestamp_column)._read_attribute(timestamp_column)
-        end
-      else
-        column_type = type_for_attribute(timestamp_column.to_s)
-        column = "#{connection.quote_table_name(collection.table_name)}.#{connection.quote_column_name(timestamp_column)}"
-        select_values = "COUNT(*) AS #{connection.quote_column_name("size")}, MAX(%s) AS timestamp"
-
-        if collection.limit_value || collection.offset_value
-          query = collection.spawn
-          query.select_values = [column]
-          subquery_alias = "subquery_for_cache_key"
-          subquery_column = "#{subquery_alias}.#{timestamp_column}"
-          subquery = query.arel.as(subquery_alias)
-          arel = Arel::SelectManager.new(query.engine).project(select_values % subquery_column).from(subquery)
-        else
-          query = collection.unscope(:order)
-          query.select_values = [select_values % column]
-          arel = query.arel
-        end
-
-        result = connection.select_one(arel, nil, query.bound_attributes)
-
-        if result.blank?
-          size = 0
-          timestamp = nil
-        else
-          size = result["size"]
-          timestamp = column_type.deserialize(result["timestamp"])
-        end
-
-      end
-
-      if timestamp
-        "#{key}-#{size}-#{timestamp.utc.to_s(cache_timestamp_format)}"
-      else
-        "#{key}-#{size}"
-      end
-    end
-  end
-end

data/lib/active_record/connection_adapters/connection_specification.rb

@@ -1,263 +0,0 @@
-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
-
-      # 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
-
-        def uri
-          @uri
-        end
-
-        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("=") }]
-        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 hash two layers deep, keys on the first layer represent
-        # environments such as "production". Keys must be strings.
-        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)
-          if config
-            resolve_connection config
-          elsif env = ActiveRecord::ConnectionHandling::RAILS_ENV.call
-            resolve_symbol_connection env.to_sym
-          else
-            raise AdapterNotSpecified
-          end
-        end
-
-        # Expands each key in @configurations hash into fully resolved hash
-        def resolve_all
-          config = configurations.dup
-          config.each do |key, value|
-            config[key] = resolve(value) if value
-          end
-          config
-        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, name = nil)
-          spec = resolve(config).symbolize_keys
-
-          raise(AdapterNotSpecified, "database configuration does not specify adapter") unless spec.key?(:adapter)
-
-          path_to_adapter = "active_record/connection_adapters/#{spec[:adapter]}_adapter"
-          begin
-            require path_to_adapter
-          rescue Gem::LoadError => e
-            raise Gem::LoadError, "Specified '#{spec[:adapter]}' for database adapter, but the gem is not loaded. Add `gem '#{e.name}'` to your Gemfile (and ensure its version is at the minimum required by ActiveRecord)."
-          rescue LoadError => e
-            raise LoadError, "Could not load '#{path_to_adapter}'. Make sure that the adapter in config/database.yml is valid. If you use an adapter other than 'mysql2', 'postgresql' or 'sqlite3' add the necessary adapter gem to the Gemfile.", e.backtrace
-          end
-
-          adapter_method = "#{spec[:adapter]}_connection"
-
-          name ||=
-            if config.is_a?(Symbol)
-              config.to_s
-            else
-              "primary"
-            end
-          ConnectionSpecification.new(name, 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(spec)
-          case spec
-          when Symbol
-            resolve_symbol_connection spec
-          when String
-            resolve_url_connection spec
-          when Hash
-            resolve_hash_connection spec
-          end
-        end
-
-        # Takes the environment such as +:production+ or +:development+.
-        # This requires that the @configurations was initialized with a key that
-        # matches.
-        #
-        #   Resolver.new("production" => {}).resolve_symbol_connection(:production)
-        #   # => {}
-        #
-        def resolve_symbol_connection(spec)
-          if config = configurations[spec.to_s]
-            resolve_connection(config)
-          else
-            raise(AdapterNotSpecified, "'#{spec}' database is not configured. Available: #{configurations.keys.inspect}")
-          end
-        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