activerecord 4.2.0 → 6.1.7.1

data/lib/active_record/attribute.rb

@@ -1,149 +0,0 @@
-module ActiveRecord
-  class Attribute # :nodoc:
-    class << self
-      def from_database(name, value, type)
-        FromDatabase.new(name, value, type)
-      end
-
-      def from_user(name, value, type)
-        FromUser.new(name, value, type)
-      end
-
-      def with_cast_value(name, value, type)
-        WithCastValue.new(name, value, type)
-      end
-
-      def null(name)
-        Null.new(name)
-      end
-
-      def uninitialized(name, type)
-        Uninitialized.new(name, type)
-      end
-    end
-
-    attr_reader :name, :value_before_type_cast, :type
-
-    # This method should not be called directly.
-    # Use #from_database or #from_user
-    def initialize(name, value_before_type_cast, type)
-      @name = name
-      @value_before_type_cast = value_before_type_cast
-      @type = type
-    end
-
-    def value
-      # `defined?` is cheaper than `||=` when we get back falsy values
-      @value = original_value unless defined?(@value)
-      @value
-    end
-
-    def original_value
-      type_cast(value_before_type_cast)
-    end
-
-    def value_for_database
-      type.type_cast_for_database(value)
-    end
-
-    def changed_from?(old_value)
-      type.changed?(old_value, value, value_before_type_cast)
-    end
-
-    def changed_in_place_from?(old_value)
-      type.changed_in_place?(old_value, value)
-    end
-
-    def with_value_from_user(value)
-      self.class.from_user(name, value, type)
-    end
-
-    def with_value_from_database(value)
-      self.class.from_database(name, value, type)
-    end
-
-    def with_cast_value(value)
-      self.class.with_cast_value(name, value, type)
-    end
-
-    def type_cast(*)
-      raise NotImplementedError
-    end
-
-    def initialized?
-      true
-    end
-
-    def ==(other)
-      self.class == other.class &&
-        name == other.name &&
-        value_before_type_cast == other.value_before_type_cast &&
-        type == other.type
-    end
-
-    protected
-
-    def initialize_dup(other)
-      if defined?(@value) && @value.duplicable?
-        @value = @value.dup
-      end
-    end
-
-    class FromDatabase < Attribute # :nodoc:
-      def type_cast(value)
-        type.type_cast_from_database(value)
-      end
-    end
-
-    class FromUser < Attribute # :nodoc:
-      def type_cast(value)
-        type.type_cast_from_user(value)
-      end
-    end
-
-    class WithCastValue < Attribute # :nodoc:
-      def type_cast(value)
-        value
-      end
-
-      def changed_in_place_from?(old_value)
-        false
-      end
-    end
-
-    class Null < Attribute # :nodoc:
-      def initialize(name)
-        super(name, nil, Type::Value.new)
-      end
-
-      def value
-        nil
-      end
-
-      def with_value_from_database(value)
-        raise ActiveModel::MissingAttributeError, "can't write unknown attribute `#{name}`"
-      end
-      alias_method :with_value_from_user, :with_value_from_database
-    end
-
-    class Uninitialized < Attribute # :nodoc:
-      def initialize(name, type)
-        super(name, nil, type)
-      end
-
-      def value
-        if block_given?
-          yield name
-        end
-      end
-
-      def value_for_database
-      end
-
-      def initialized?
-        false
-      end
-    end
-    private_constant :FromDatabase, :FromUser, :Null, :Uninitialized
-  end
-end

data/lib/active_record/attribute_decorators.rb

@@ -1,66 +0,0 @@
-module ActiveRecord
-  module AttributeDecorators # :nodoc:
-    extend ActiveSupport::Concern
-
-    included do
-      class_attribute :attribute_type_decorations, instance_accessor: false # :internal:
-      self.attribute_type_decorations = TypeDecorator.new
-    end
-
-    module ClassMethods # :nodoc:
-      def decorate_attribute_type(column_name, decorator_name, &block)
-        matcher = ->(name, _) { name == column_name.to_s }
-        key = "_#{column_name}_#{decorator_name}"
-        decorate_matching_attribute_types(matcher, key, &block)
-      end
-
-      def decorate_matching_attribute_types(matcher, decorator_name, &block)
-        clear_caches_calculated_from_columns
-        decorator_name = decorator_name.to_s
-
-        # Create new hashes so we don't modify parent classes
-        self.attribute_type_decorations = attribute_type_decorations.merge(decorator_name => [matcher, block])
-      end
-
-      private
-
-      def add_user_provided_columns(*)
-        super.map do |column|
-          decorated_type = attribute_type_decorations.apply(column.name, column.cast_type)
-          column.with_type(decorated_type)
-        end
-      end
-    end
-
-    class TypeDecorator # :nodoc:
-      delegate :clear, to: :@decorations
-
-      def initialize(decorations = {})
-        @decorations = decorations
-      end
-
-      def merge(*args)
-        TypeDecorator.new(@decorations.merge(*args))
-      end
-
-      def apply(name, type)
-        decorations = decorators_for(name, type)
-        decorations.inject(type) do |new_type, block|
-          block.call(new_type)
-        end
-      end
-
-      private
-
-      def decorators_for(name, type)
-        matching(name, type).map(&:last)
-      end
-
-      def matching(name, type)
-        @decorations.values.select do |(matcher, _)|
-          matcher.call(name, type)
-        end
-      end
-    end
-  end
-end

data/lib/active_record/attribute_set/builder.rb

@@ -1,86 +0,0 @@
-module ActiveRecord
-  class AttributeSet # :nodoc:
-    class Builder # :nodoc:
-      attr_reader :types, :always_initialized
-
-      def initialize(types, always_initialized = nil)
-        @types = types
-        @always_initialized = always_initialized
-      end
-
-      def build_from_database(values = {}, additional_types = {})
-        if always_initialized && !values.key?(always_initialized)
-          values[always_initialized] = nil
-        end
-
-        attributes = LazyAttributeHash.new(types, values, additional_types)
-        AttributeSet.new(attributes)
-      end
-    end
-  end
-
-  class LazyAttributeHash # :nodoc:
-    delegate :select, :transform_values, to: :materialize
-
-    def initialize(types, values, additional_types)
-      @types = types
-      @values = values
-      @additional_types = additional_types
-      @materialized = false
-      @delegate_hash = {}
-    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 initialized_keys
-      delegate_hash.keys | values.keys
-    end
-
-    def initialize_dup(_)
-      @delegate_hash = delegate_hash.transform_values(&:dup)
-      super
-    end
-
-    protected
-
-    attr_reader :types, :values, :additional_types, :delegate_hash
-
-    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)
-        delegate_hash[name] = Attribute.uninitialized(name, type)
-      end
-    end
-
-    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
-  end
-end

data/lib/active_record/attribute_set.rb

@@ -1,77 +0,0 @@
-require 'active_record/attribute_set/builder'
-
-module ActiveRecord
-  class AttributeSet # :nodoc:
-    def initialize(attributes)
-      @attributes = attributes
-    end
-
-    def [](name)
-      attributes[name] || Attribute.null(name)
-    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.initialized_keys
-    end
-
-    def fetch_value(name)
-      self[name].value { |n| yield n if block_given? }
-    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 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
-
-    protected
-
-    attr_reader :attributes
-
-    private
-
-    def initialized_attributes
-      attributes.select { |_, attr| attr.initialized? }
-    end
-  end
-end

data/lib/active_record/connection_adapters/connection_specification.rb

@@ -1,275 +0,0 @@
-require 'uri'
-require 'active_support/core_ext/string/filters'
-
-module ActiveRecord
-  module ConnectionAdapters
-    class ConnectionSpecification #:nodoc:
-      attr_reader :config, :adapter_method
-
-      def initialize(config, adapter_method)
-        @config, @adapter_method = 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.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)
-          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 'mysql', 'mysql2', 'postgresql' or 'sqlite3' add the necessary adapter gem to the Gemfile.", e.backtrace
-          end
-
-          adapter_method = "#{spec[:adapter]}_connection"
-          ConnectionSpecification.new(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_string_connection spec
-          when Hash
-            resolve_hash_connection spec
-          end
-        end
-
-        def resolve_string_connection(spec)
-          # Rails has historically accepted a string to mean either
-          # an environment key or a URL spec, so we have deprecated
-          # this ambiguous behaviour and in the future this function
-          # can be removed in favor of resolve_url_connection.
-          if configurations.key?(spec) || spec !~ /:/
-            ActiveSupport::Deprecation.warn(<<-MSG.squish)
-              Passing a string to ActiveRecord::Base.establish_connection for a
-              configuration lookup is deprecated, please pass a symbol
-              (#{spec.to_sym.inspect}) instead.
-            MSG
-
-            resolve_symbol_connection(spec)
-          else
-            resolve_url_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