activerecord 4.2.0 → 6.1.7.1

data/lib/active_record/database_configurations.rb

@@ -0,0 +1,273 @@
+# frozen_string_literal: true
+
+require "uri"
+require "active_record/database_configurations/database_config"
+require "active_record/database_configurations/hash_config"
+require "active_record/database_configurations/url_config"
+require "active_record/database_configurations/connection_url_resolver"
+
+module ActiveRecord
+  # ActiveRecord::DatabaseConfigurations returns an array of DatabaseConfig
+  # objects (either a HashConfig or UrlConfig) that are constructed from the
+  # application's database configuration hash or URL string.
+  class DatabaseConfigurations
+    class InvalidConfigurationError < StandardError; end
+
+    attr_reader :configurations
+    delegate :any?, to: :configurations
+
+    def initialize(configurations = {})
+      @configurations = build_configs(configurations)
+    end
+
+    # Collects the configs for the environment and optionally the specification
+    # name passed in. To include replica configurations pass <tt>include_replicas: true</tt>.
+    #
+    # If a name is provided a single DatabaseConfig object will be
+    # returned, otherwise an array of DatabaseConfig objects will be
+    # returned that corresponds with the environment and type requested.
+    #
+    # ==== Options
+    #
+    # * <tt>env_name:</tt> The environment name. Defaults to +nil+ which will collect
+    #   configs for all environments.
+    # * <tt>name:</tt> The db config name (i.e. primary, animals, etc.). Defaults
+    #   to +nil+. If no +env_name+ is specified the config for the default env and the
+    #   passed +name+ will be returned.
+    # * <tt>include_replicas:</tt> Determines whether to include replicas in
+    #   the returned list. Most of the time we're only iterating over the write
+    #   connection (i.e. migrations don't need to run for the write and read connection).
+    #   Defaults to +false+.
+    def configs_for(env_name: nil, spec_name: nil, name: nil, include_replicas: false)
+      if spec_name
+        name = spec_name
+        ActiveSupport::Deprecation.warn("The kwarg `spec_name` is deprecated in favor of `name`. `spec_name` will be removed in Rails 7.0")
+      end
+
+      env_name ||= default_env if name
+      configs = env_with_configs(env_name)
+
+      unless include_replicas
+        configs = configs.select do |db_config|
+          !db_config.replica?
+        end
+      end
+
+      if name
+        configs.find do |db_config|
+          db_config.name == name
+        end
+      else
+        configs
+      end
+    end
+
+    # Returns the config hash that corresponds with the environment
+    #
+    # If the application has multiple databases +default_hash+ will
+    # return the first config hash for the environment.
+    #
+    #   { database: "my_db", adapter: "mysql2" }
+    def default_hash(env = default_env)
+      default = find_db_config(env)
+      default.configuration_hash if default
+    end
+    alias :[] :default_hash
+    deprecate "[]": "Use configs_for", default_hash: "Use configs_for"
+
+    # Returns a single DatabaseConfig object based on the requested environment.
+    #
+    # If the application has multiple databases +find_db_config+ will return
+    # the first DatabaseConfig for the environment.
+    def find_db_config(env)
+      configurations
+        .sort_by.with_index { |db_config, i| db_config.for_current_env? ? [0, i] : [1, i] }
+        .find do |db_config|
+          db_config.env_name == env.to_s ||
+            (db_config.for_current_env? && db_config.name == env.to_s)
+        end
+    end
+
+    # A primary configuration is one that is named primary or if there is
+    # no primary, the first configuration for an environment will be treated
+    # as primary. This is used as the "default" configuration and is used
+    # when the application needs to treat one configuration differently. For
+    # example, when Rails dumps the schema, the primary configuration's schema
+    # file will be named `schema.rb` instead of `primary_schema.rb`.
+    def primary?(name) # :nodoc:
+      return true if name == "primary"
+
+      first_config = find_db_config(default_env)
+      first_config && name == first_config.name
+    end
+
+    # Returns the DatabaseConfigurations object as a Hash.
+    def to_h
+      configurations.inject({}) do |memo, db_config|
+        memo.merge(db_config.env_name => db_config.configuration_hash.stringify_keys)
+      end
+    end
+    deprecate to_h: "You can use `ActiveRecord::Base.configurations.configs_for(env_name: 'env', name: 'primary').configuration_hash` to get the configuration hashes."
+
+    # Checks if the application's configurations are empty.
+    #
+    # Aliased to blank?
+    def empty?
+      configurations.empty?
+    end
+    alias :blank? :empty?
+
+    # Returns fully resolved connection, accepts hash, string or symbol.
+    # Always returns a DatabaseConfiguration::DatabaseConfig
+    #
+    # == Examples
+    #
+    # Symbol representing current environment.
+    #
+    #   DatabaseConfigurations.new("production" => {}).resolve(:production)
+    #   # => DatabaseConfigurations::HashConfig.new(env_name: "production", config: {})
+    #
+    # One layer deep hash of connection values.
+    #
+    #   DatabaseConfigurations.new({}).resolve("adapter" => "sqlite3")
+    #   # => DatabaseConfigurations::HashConfig.new(config: {"adapter" => "sqlite3"})
+    #
+    # Connection URL.
+    #
+    #   DatabaseConfigurations.new({}).resolve("postgresql://localhost/foo")
+    #   # => DatabaseConfigurations::UrlConfig.new(config: {"adapter" => "postgresql", "host" => "localhost", "database" => "foo"})
+    def resolve(config) # :nodoc:
+      return config if DatabaseConfigurations::DatabaseConfig === config
+
+      case config
+      when Symbol
+        resolve_symbol_connection(config)
+      when Hash, String
+        build_db_config_from_raw_config(default_env, "primary", config)
+      else
+        raise TypeError, "Invalid type for configuration. Expected Symbol, String, or Hash. Got #{config.inspect}"
+      end
+    end
+
+    private
+      def default_env
+        ActiveRecord::ConnectionHandling::DEFAULT_ENV.call.to_s
+      end
+
+      def env_with_configs(env = nil)
+        if env
+          configurations.select { |db_config| db_config.env_name == env }
+        else
+          configurations
+        end
+      end
+
+      def build_configs(configs)
+        return configs.configurations if configs.is_a?(DatabaseConfigurations)
+        return configs if configs.is_a?(Array)
+
+        db_configs = configs.flat_map do |env_name, config|
+          if config.is_a?(Hash) && config.all? { |_, v| v.is_a?(Hash) }
+            walk_configs(env_name.to_s, config)
+          else
+            build_db_config_from_raw_config(env_name.to_s, "primary", config)
+          end
+        end
+
+        unless db_configs.find(&:for_current_env?)
+          db_configs << environment_url_config(default_env, "primary", {})
+        end
+
+        merge_db_environment_variables(default_env, db_configs.compact)
+      end
+
+      def walk_configs(env_name, config)
+        config.map do |name, sub_config|
+          build_db_config_from_raw_config(env_name, name.to_s, sub_config)
+        end
+      end
+
+      def resolve_symbol_connection(name)
+        if db_config = find_db_config(name)
+          db_config
+        else
+          raise AdapterNotSpecified, <<~MSG
+            The `#{name}` database is not configured for the `#{default_env}` environment.
+
+              Available databases configurations are:
+
+              #{build_configuration_sentence}
+          MSG
+        end
+      end
+
+      def build_configuration_sentence
+        configs = configs_for(include_replicas: true)
+
+        configs.group_by(&:env_name).map do |env, config|
+          names = config.map(&:name)
+          if names.size > 1
+            "#{env}: #{names.join(", ")}"
+          else
+            env
+          end
+        end.join("\n")
+      end
+
+      def build_db_config_from_raw_config(env_name, name, config)
+        case config
+        when String
+          build_db_config_from_string(env_name, name, config)
+        when Hash
+          build_db_config_from_hash(env_name, name, config.symbolize_keys)
+        else
+          raise InvalidConfigurationError, "'{ #{env_name} => #{config} }' is not a valid configuration. Expected '#{config}' to be a URL string or a Hash."
+        end
+      end
+
+      def build_db_config_from_string(env_name, name, config)
+        url = config
+        uri = URI.parse(url)
+        if uri.scheme
+          UrlConfig.new(env_name, name, url)
+        else
+          raise InvalidConfigurationError, "'{ #{env_name} => #{config} }' is not a valid configuration. Expected '#{config}' to be a URL string or a Hash."
+        end
+      end
+
+      def build_db_config_from_hash(env_name, name, config)
+        if config.has_key?(:url)
+          url = config[:url]
+          config_without_url = config.dup
+          config_without_url.delete :url
+
+          UrlConfig.new(env_name, name, url, config_without_url)
+        else
+          HashConfig.new(env_name, name, config)
+        end
+      end
+
+      def merge_db_environment_variables(current_env, configs)
+        configs.map do |config|
+          next config if config.is_a?(UrlConfig) || config.env_name != current_env
+
+          url_config = environment_url_config(current_env, config.name, config.configuration_hash)
+          url_config || config
+        end
+      end
+
+      def environment_url_config(env, name, config)
+        url = environment_value_for(name)
+        return unless url
+
+        UrlConfig.new(env, name, url, config)
+      end
+
+      def environment_value_for(name)
+        name_env_key = "#{name.upcase}_DATABASE_URL"
+        url = ENV[name_env_key]
+        url ||= ENV["DATABASE_URL"] if name == "primary"
+        url
+      end
+  end
+end

data/lib/active_record/delegated_type.rb

@@ -0,0 +1,209 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/string/inquiry"
+
+module ActiveRecord
+  # == Delegated types
+  #
+  # Class hierarchies can map to relational database tables in many ways. Active Record, for example, offers
+  # purely abstract classes, where the superclass doesn't persist any attributes, and single-table inheritance,
+  # where all attributes from all levels of the hierarchy are represented in a single table. Both have their
+  # places, but neither are without their drawbacks.
+  #
+  # The problem with purely abstract classes is that all concrete subclasses must persist all the shared
+  # attributes themselves in their own tables (also known as class-table inheritance). This makes it hard to
+  # do queries across the hierarchy. For example, imagine you have the following hierarchy:
+  #
+  #   Entry < ApplicationRecord
+  #   Message < Entry
+  #   Comment < Entry
+  #
+  # How do you show a feed that has both +Message+ and +Comment+ records, which can be easily paginated?
+  # Well, you can't! Messages are backed by a messages table and comments by a comments table. You can't
+  # pull from both tables at once and use a consistent OFFSET/LIMIT scheme.
+  #
+  # You can get around the pagination problem by using single-table inheritance, but now you're forced into
+  # a single mega table with all the attributes from all subclasses. No matter how divergent. If a Message
+  # has a subject, but the comment does not, well, now the comment does anyway! So STI works best when there's
+  # little divergence between the subclasses and their attributes.
+  #
+  # But there's a third way: Delegated types. With this approach, the "superclass" is a concrete class
+  # that is represented by its own table, where all the superclass attributes that are shared amongst all the
+  # "subclasses" are stored. And then each of the subclasses have their own individual tables for additional
+  # attributes that are particular to their implementation. This is similar to what's called multi-table
+  # inheritance in Django, but instead of actual inheritance, this approach uses delegation to form the
+  # hierarchy and share responsibilities.
+  #
+  # Let's look at that entry/message/comment example using delegated types:
+  #
+  #   # Schema: entries[ id, account_id, creator_id, created_at, updated_at, entryable_type, entryable_id ]
+  #   class Entry < ApplicationRecord
+  #     belongs_to :account
+  #     belongs_to :creator
+  #     delegated_type :entryable, types: %w[ Message Comment ]
+  #   end
+  #
+  #   module Entryable
+  #     extend ActiveSupport::Concern
+  #
+  #     included do
+  #       has_one :entry, as: :entryable, touch: true
+  #     end
+  #   end
+  #
+  #   # Schema: messages[ id, subject ]
+  #   class Message < ApplicationRecord
+  #     include Entryable
+  #     has_rich_text :content
+  #   end
+  #
+  #   # Schema: comments[ id, content ]
+  #   class Comment < ApplicationRecord
+  #     include Entryable
+  #   end
+  #
+  # As you can see, neither +Message+ nor +Comment+ are meant to stand alone. Crucial metadata for both classes
+  # resides in the +Entry+ "superclass". But the +Entry+ absolutely can stand alone in terms of querying capacity
+  # in particular. You can now easily do things like:
+  #
+  #   Account.entries.order(created_at: :desc).limit(50)
+  #
+  # Which is exactly what you want when displaying both comments and messages together. The entry itself can
+  # be rendered as its delegated type easily, like so:
+  #
+  #   # entries/_entry.html.erb
+  #   <%= render "entries/entryables/#{entry.entryable_name}", entry: entry %>
+  #
+  #   # entries/entryables/_message.html.erb
+  #   <div class="message">
+  #     Posted on <%= entry.created_at %> by <%= entry.creator.name %>: <%= entry.message.content %>
+  #   </div>
+  #
+  #   # entries/entryables/_comment.html.erb
+  #   <div class="comment">
+  #     <%= entry.creator.name %> said: <%= entry.comment.content %>
+  #   </div>
+  #
+  # == Sharing behavior with concerns and controllers
+  #
+  # The entry "superclass" also serves as a perfect place to put all that shared logic that applies to both
+  # messages and comments, and which acts primarily on the shared attributes. Imagine:
+  #
+  #   class Entry < ApplicationRecord
+  #     include Eventable, Forwardable, Redeliverable
+  #   end
+  #
+  # Which allows you to have controllers for things like +ForwardsController+ and +RedeliverableController+
+  # that both act on entries, and thus provide the shared functionality to both messages and comments.
+  #
+  # == Creating new records
+  #
+  # You create a new record that uses delegated typing by creating the delegator and delegatee at the same time,
+  # like so:
+  #
+  #   Entry.create! entryable: Comment.new(content: "Hello!"), creator: Current.user
+  #
+  # If you need more complicated composition, or you need to perform dependent validation, you should build a factory
+  # method or class to take care of the complicated needs. This could be as simple as:
+  #
+  #   class Entry < ApplicationRecord
+  #     def self.create_with_comment(content, creator: Current.user)
+  #       create! entryable: Comment.new(content: content), creator: creator
+  #     end
+  #   end
+  #
+  # == Adding further delegation
+  #
+  # The delegated type shouldn't just answer the question of what the underlying class is called. In fact, that's
+  # an anti-pattern most of the time. The reason you're building this hierarchy is to take advantage of polymorphism.
+  # So here's a simple example of that:
+  #
+  #   class Entry < ApplicationRecord
+  #     delegated_type :entryable, types: %w[ Message Comment ]
+  #     delegate :title, to: :entryable
+  #   end
+  #
+  #   class Message < ApplicationRecord
+  #     def title
+  #       subject
+  #     end
+  #   end
+  #
+  #   class Comment < ApplicationRecord
+  #     def title
+  #       content.truncate(20)
+  #     end
+  #   end
+  #
+  # Now you can list a bunch of entries, call +Entry#title+, and polymorphism will provide you with the answer.
+  module DelegatedType
+    # Defines this as a class that'll delegate its type for the passed +role+ to the class references in +types+.
+    # That'll create a polymorphic +belongs_to+ relationship to that +role+, and it'll add all the delegated
+    # type convenience methods:
+    #
+    #   class Entry < ApplicationRecord
+    #     delegated_type :entryable, types: %w[ Message Comment ], dependent: :destroy
+    #   end
+    #
+    #   Entry#entryable_class # => +Message+ or +Comment+
+    #   Entry#entryable_name  # => "message" or "comment"
+    #   Entry.messages        # => Entry.where(entryable_type: "Message")
+    #   Entry#message?        # => true when entryable_type == "Message"
+    #   Entry#message         # => returns the message record, when entryable_type == "Message", otherwise nil
+    #   Entry#message_id      # => returns entryable_id, when entryable_type == "Message", otherwise nil
+    #   Entry.comments        # => Entry.where(entryable_type: "Comment")
+    #   Entry#comment?        # => true when entryable_type == "Comment"
+    #   Entry#comment         # => returns the comment record, when entryable_type == "Comment", otherwise nil
+    #   Entry#comment_id      # => returns entryable_id, when entryable_type == "Comment", otherwise nil
+    #
+    # The +options+ are passed directly to the +belongs_to+ call, so this is where you declare +dependent+ etc.
+    #
+    # You can also declare namespaced types:
+    #
+    #   class Entry < ApplicationRecord
+    #     delegated_type :entryable, types: %w[ Message Comment Access::NoticeMessage ], dependent: :destroy
+    #   end
+    #
+    #   Entry.access_notice_messages
+    #   entry.access_notice_message
+    #   entry.access_notice_message?
+    def delegated_type(role, types:, **options)
+      belongs_to role, options.delete(:scope), **options.merge(polymorphic: true)
+      define_delegated_type_methods role, types: types
+    end
+
+    private
+      def define_delegated_type_methods(role, types:)
+        role_type = "#{role}_type"
+        role_id   = "#{role}_id"
+
+        define_method "#{role}_class" do
+          public_send("#{role}_type").constantize
+        end
+
+        define_method "#{role}_name" do
+          public_send("#{role}_class").model_name.singular.inquiry
+        end
+
+        types.each do |type|
+          scope_name = type.tableize.gsub("/", "_")
+          singular   = scope_name.singularize
+          query      = "#{singular}?"
+
+          scope scope_name, -> { where(role_type => type) }
+
+          define_method query do
+            public_send(role_type) == type
+          end
+
+          define_method singular do
+            public_send(role) if public_send(query)
+          end
+
+          define_method "#{singular}_id" do
+            public_send(role_id) if public_send(query)
+          end
+        end
+      end
+  end
+end

data/lib/active_record/destroy_association_async_job.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  class DestroyAssociationAsyncError < StandardError
+  end
+
+  # Job to destroy the records associated with a destroyed record in background.
+  class DestroyAssociationAsyncJob < ActiveJob::Base
+    queue_as { ActiveRecord::Base.queues[:destroy] }
+
+    discard_on ActiveJob::DeserializationError
+
+    def perform(
+      owner_model_name: nil, owner_id: nil,
+      association_class: nil, association_ids: nil, association_primary_key_column: nil,
+      ensuring_owner_was_method: nil
+    )
+      association_model = association_class.constantize
+      owner_class = owner_model_name.constantize
+      owner = owner_class.find_by(owner_class.primary_key.to_sym => owner_id)
+
+      if !owner_destroyed?(owner, ensuring_owner_was_method)
+        raise DestroyAssociationAsyncError, "owner record not destroyed"
+      end
+
+      association_model.where(association_primary_key_column => association_ids).find_each do |r|
+        r.destroy
+      end
+    end
+
+    private
+      def owner_destroyed?(owner, ensuring_owner_was_method)
+        !owner || (ensuring_owner_was_method && owner.public_send(ensuring_owner_was_method))
+      end
+  end
+end