tallty_duck_record 1.0.0

data/lib/duck_record/nested_validate_association.rb

@@ -0,0 +1,262 @@
+module DuckRecord
+  # = Active Record Autosave Association
+  #
+  # AutosaveAssociation is a module that takes care of automatically saving
+  # associated records when their parent is saved. In addition to saving, it
+  # also destroys any associated records that were marked for destruction.
+  # (See #mark_for_destruction and #marked_for_destruction?).
+  #
+  # Saving of the parent, its associations, and the destruction of marked
+  # associations, all happen inside a transaction. This should never leave the
+  # database in an inconsistent state.
+  #
+  # If validations for any of the associations fail, their error messages will
+  # be applied to the parent.
+  #
+  # Note that it also means that associations marked for destruction won't
+  # be destroyed directly. They will however still be marked for destruction.
+  #
+  # Note that <tt>autosave: false</tt> is not same as not declaring <tt>:autosave</tt>.
+  # When the <tt>:autosave</tt> option is not present then new association records are
+  # saved but the updated association records are not saved.
+  #
+  # == Validation
+  #
+  # Child records are validated unless <tt>:validate</tt> is +false+.
+  #
+  # == Callbacks
+  #
+  # Association with autosave option defines several callbacks on your
+  # model (before_save, after_create, after_update). Please note that
+  # callbacks are executed in the order they were defined in
+  # model. You should avoid modifying the association content, before
+  # autosave callbacks are executed. Placing your callbacks after
+  # associations is usually a good practice.
+  #
+  # === One-to-one Example
+  #
+  #   class Post < ActiveRecord::Base
+  #     has_one :author, autosave: true
+  #   end
+  #
+  # Saving changes to the parent and its associated model can now be performed
+  # automatically _and_ atomically:
+  #
+  #   post = Post.find(1)
+  #   post.title       # => "The current global position of migrating ducks"
+  #   post.author.name # => "alloy"
+  #
+  #   post.title = "On the migration of ducks"
+  #   post.author.name = "Eloy Duran"
+  #
+  #   post.save
+  #   post.reload
+  #   post.title       # => "On the migration of ducks"
+  #   post.author.name # => "Eloy Duran"
+  #
+  # Destroying an associated model, as part of the parent's save action, is as
+  # simple as marking it for destruction:
+  #
+  #   post.author.mark_for_destruction
+  #   post.author.marked_for_destruction? # => true
+  #
+  # Note that the model is _not_ yet removed from the database:
+  #
+  #   id = post.author.id
+  #   Author.find_by(id: id).nil? # => false
+  #
+  #   post.save
+  #   post.reload.author # => nil
+  #
+  # Now it _is_ removed from the database:
+  #
+  #   Author.find_by(id: id).nil? # => true
+  #
+  # === One-to-many Example
+  #
+  # When <tt>:autosave</tt> is not declared new children are saved when their parent is saved:
+  #
+  #   class Post < ActiveRecord::Base
+  #     has_many :comments # :autosave option is not declared
+  #   end
+  #
+  #   post = Post.new(title: 'ruby rocks')
+  #   post.comments.build(body: 'hello world')
+  #   post.save # => saves both post and comment
+  #
+  #   post = Post.create(title: 'ruby rocks')
+  #   post.comments.build(body: 'hello world')
+  #   post.save # => saves both post and comment
+  #
+  #   post = Post.create(title: 'ruby rocks')
+  #   post.comments.create(body: 'hello world')
+  #   post.save # => saves both post and comment
+  #
+  # When <tt>:autosave</tt> is true all children are saved, no matter whether they
+  # are new records or not:
+  #
+  #   class Post < ActiveRecord::Base
+  #     has_many :comments, autosave: true
+  #   end
+  #
+  #   post = Post.create(title: 'ruby rocks')
+  #   post.comments.create(body: 'hello world')
+  #   post.comments[0].body = 'hi everyone'
+  #   post.comments.build(body: "good morning.")
+  #   post.title += "!"
+  #   post.save # => saves both post and comments.
+  #
+  # Destroying one of the associated models as part of the parent's save action
+  # is as simple as marking it for destruction:
+  #
+  #   post.comments # => [#<Comment id: 1, ...>, #<Comment id: 2, ...]>
+  #   post.comments[1].mark_for_destruction
+  #   post.comments[1].marked_for_destruction? # => true
+  #   post.comments.length # => 2
+  #
+  # Note that the model is _not_ yet removed from the database:
+  #
+  #   id = post.comments.last.id
+  #   Comment.find_by(id: id).nil? # => false
+  #
+  #   post.save
+  #   post.reload.comments.length # => 1
+  #
+  # Now it _is_ removed from the database:
+  #
+  #   Comment.find_by(id: id).nil? # => true
+  module NestedValidateAssociation
+    extend ActiveSupport::Concern
+
+    module AssociationBuilderExtension #:nodoc:
+      def self.build(model, reflection)
+        model.send(:add_nested_validate_association_callbacks, reflection)
+      end
+
+      def self.valid_options
+        []
+      end
+    end
+
+    included do
+      Associations::Builder::Association.extensions << AssociationBuilderExtension
+      mattr_accessor :index_nested_attribute_errors, instance_writer: false
+      self.index_nested_attribute_errors = false
+    end
+
+    module ClassMethods # :nodoc:
+      private
+
+      def define_non_cyclic_method(name, &block)
+        return if method_defined?(name)
+        define_method(name) do |*args|
+          result = true; @_already_called ||= {}
+          # Loop prevention for validation of associations
+          unless @_already_called[name]
+            begin
+              @_already_called[name] = true
+              result = instance_eval(&block)
+            ensure
+              @_already_called[name] = false
+            end
+          end
+
+          result
+        end
+      end
+
+      # Adds validation and save callbacks for the association as specified by
+      # the +reflection+.
+      #
+      # For performance reasons, we don't check whether to validate at runtime.
+      # However the validation and callback methods are lazy and those methods
+      # get created when they are invoked for the very first time. However,
+      # this can change, for instance, when using nested attributes, which is
+      # called _after_ the association has been defined. Since we don't want
+      # the callbacks to get defined multiple times, there are guards that
+      # check if the save or validation methods have already been defined
+      # before actually defining them.
+      def add_nested_validate_association_callbacks(reflection)
+        validation_method = :"validate_associated_records_for_#{reflection.name}"
+        if reflection.validate? && !method_defined?(validation_method)
+          if reflection.collection?
+            method = :validate_collection_association
+          else
+            method = :validate_single_association
+          end
+
+          define_non_cyclic_method(validation_method) do
+            send(method, reflection)
+            # TODO: remove the following line as soon as the return value of
+            # callbacks is ignored, that is, returning `false` does not
+            # display a deprecation warning or halts the callback chain.
+            true
+          end
+          validate validation_method
+          after_validation :_ensure_no_duplicate_errors
+        end
+      end
+    end
+
+    private
+
+    # Validate the association if <tt>:validate</tt> or <tt>:autosave</tt> is
+    # turned on for the association.
+    def validate_single_association(reflection)
+      association = association_instance_get(reflection.name)
+      record      = association&.reader
+      association_valid?(reflection, record) if record
+    end
+
+    # Validate the associated records if <tt>:validate</tt> or
+    # <tt>:autosave</tt> is turned on for the association specified by
+    # +reflection+.
+    def validate_collection_association(reflection)
+      if association = association_instance_get(reflection.name)
+        if records = association.target
+          records.each_with_index { |record, index| association_valid?(reflection, record, index) }
+        end
+      end
+    end
+
+    # Returns whether or not the association is valid and applies any errors to
+    # the parent, <tt>self</tt>, if it wasn't. Skips any <tt>:autosave</tt>
+    # enabled records if they're marked_for_destruction? or destroyed.
+    def association_valid?(reflection, record, index = nil)
+      unless valid = record.valid?
+        indexed_attribute = !index.nil? && (reflection.options[:index_errors] || DuckRecord::Base.index_nested_attribute_errors)
+
+        record.errors.each do |attribute, message|
+          attribute = normalize_reflection_attribute(indexed_attribute, reflection, index, attribute)
+          errors[attribute] << message
+          errors[attribute].uniq!
+        end
+
+        record.errors.details.each_key do |attribute|
+          reflection_attribute =
+            normalize_reflection_attribute(indexed_attribute, reflection, index, attribute).to_sym
+
+          record.errors.details[attribute].each do |error|
+            errors.details[reflection_attribute] << error
+            errors.details[reflection_attribute].uniq!
+          end
+        end
+      end
+      valid
+    end
+
+    def normalize_reflection_attribute(indexed_attribute, reflection, index, attribute)
+      if indexed_attribute
+        "#{reflection.name}[#{index}].#{attribute}"
+      else
+        "#{reflection.name}.#{attribute}"
+      end
+    end
+
+    def _ensure_no_duplicate_errors
+      errors.messages.each_key do |attribute|
+        errors[attribute].uniq!
+      end
+    end
+  end
+end

data/lib/duck_record/persistence.rb

@@ -0,0 +1,39 @@
+module DuckRecord
+  # = DuckRecord \Persistence
+  module Persistence
+    extend ActiveSupport::Concern
+
+    def persisted?
+      false
+    end
+
+    def destroyed?
+      false
+    end
+
+    def new_record?
+      true
+    end
+
+    # Returns an instance of the specified +klass+ with the attributes of the
+    # current record. This is mostly useful in relation to single-table
+    # inheritance structures where you want a subclass to appear as the
+    # superclass. This can be used along with record identification in
+    # Action Pack to allow, say, <tt>Client < Company</tt> to do something
+    # like render <tt>partial: @client.becomes(Company)</tt> to render that
+    # instance using the companies/company partial instead of clients/client.
+    #
+    # Note: The new instance will share a link to the same attributes as the original class.
+    # Therefore the sti column value will still be the same.
+    # Any change to the attributes on either instance will affect both instances.
+    # If you want to change the sti column as well, use #becomes! instead.
+    def becomes(klass)
+      became = klass.new
+      became.instance_variable_set("@attributes", @attributes)
+      became.instance_variable_set("@mutation_tracker", @mutation_tracker) if defined?(@mutation_tracker)
+      became.instance_variable_set("@changed_attributes", attributes_changed_by_setter)
+      became.errors.copy!(errors)
+      became
+    end
+  end
+end

data/lib/duck_record/readonly_attributes.rb

@@ -0,0 +1,36 @@
+module DuckRecord
+  module ReadonlyAttributes
+    extend ActiveSupport::Concern
+
+    included do
+      attr_accessor :_attr_readonly_enabled
+      class_attribute :_attr_readonly, instance_accessor: false
+      self._attr_readonly = []
+    end
+
+    def attr_readonly_enabled?
+      _attr_readonly_enabled
+    end
+
+    def enable_attr_readonly!
+      self._attr_readonly_enabled = true
+    end
+
+    def disable_attr_readonly!
+      self._attr_readonly_enabled = false
+    end
+
+    module ClassMethods
+      # Attributes listed as readonly will be used to create a new record but update operations will
+      # ignore these fields.
+      def attr_readonly(*attributes)
+        self._attr_readonly = Set.new(attributes.map(&:to_s)) + (_attr_readonly || [])
+      end
+
+      # Returns an array of all the attributes that have been specified as readonly.
+      def readonly_attributes
+        _attr_readonly
+      end
+    end
+  end
+end

data/lib/duck_record/reflection.rb

@@ -0,0 +1,650 @@
+require "thread"
+require "active_support/core_ext/string/filters"
+require "active_support/deprecation"
+
+module DuckRecord
+  # = Active Record Reflection
+  module Reflection # :nodoc:
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :_reflections, instance_writer: false
+      self._reflections = {}
+    end
+
+    def self.create(macro, name, scope, options, ar)
+      klass = \
+        case macro
+        when :embeds_many
+          EmbedsManyReflection
+        when :embeds_one
+          EmbedsOneReflection
+        when :belongs_to
+          BelongsToReflection
+        when :has_many
+          HasManyReflection
+        when :has_one
+          HasOneReflection
+        else
+          raise "Unsupported Macro: #{macro}"
+        end
+
+      klass.new(name, scope, options, ar)
+    end
+
+    def self.add_reflection(ar, name, reflection)
+      ar.clear_reflections_cache
+      ar._reflections = ar._reflections.merge(name.to_s => reflection)
+    end
+
+    def has_reflection?(reflection_name)
+      _reflections.keys.include?(reflection_name.to_s)
+    end
+
+    # \Reflection enables the ability to examine the associations and aggregations of
+    # Active Record classes and objects. This information, for example,
+    # can be used in a form builder that takes an Active Record object
+    # and creates input fields for all of the attributes depending on their type
+    # and displays the associations to other objects.
+    #
+    # MacroReflection class has info for AggregateReflection and AssociationReflection
+    # classes.
+    module ClassMethods
+      # Returns a Hash of name of the reflection as the key and an AssociationReflection as the value.
+      #
+      #   Account.reflections # => {"balance" => AggregateReflection}
+      #
+      def reflections
+        @__reflections ||= begin
+          ref = {}
+
+          _reflections.each do |name, reflection|
+            parent_reflection = reflection.parent_reflection
+
+            if parent_reflection
+              parent_name = parent_reflection.name
+              ref[parent_name.to_s] = parent_reflection
+            else
+              ref[name] = reflection
+            end
+          end
+
+          ref
+        end
+      end
+
+      # Returns an array of AssociationReflection objects for all the
+      # associations in the class. If you only want to reflect on a certain
+      # association type, pass in the symbol (<tt>:has_many</tt>, <tt>:has_one</tt>,
+      # <tt>:belongs_to</tt>) as the first parameter.
+      #
+      # Example:
+      #
+      #   Account.reflect_on_all_associations             # returns an array of all associations
+      #   Account.reflect_on_all_associations(:has_many)  # returns an array of all has_many associations
+      #
+      def reflect_on_all_associations(macro = nil)
+        association_reflections = reflections.values
+        association_reflections.select! { |reflection| reflection.macro == macro } if macro
+        association_reflections
+      end
+
+      # Returns the AssociationReflection object for the +association+ (use the symbol).
+      #
+      #   Account.reflect_on_association(:owner)             # returns the owner AssociationReflection
+      #   Invoice.reflect_on_association(:line_items).macro  # returns :has_many
+      #
+      def reflect_on_association(association)
+        reflections[association.to_s]
+      end
+
+      def _reflect_on_association(association) #:nodoc:
+        _reflections[association.to_s]
+      end
+
+      def clear_reflections_cache # :nodoc:
+        @__reflections = nil
+      end
+    end
+
+    # Holds all the methods that are shared between MacroReflection and ThroughReflection.
+    #
+    #   AbstractReflection
+    #     MacroReflection
+    #       AggregateReflection
+    #       AssociationReflection
+    #         HasManyReflection
+    #         HasOneReflection
+    #         BelongsToReflection
+    #         HasAndBelongsToManyReflection
+    #     ThroughReflection
+    #     PolymorphicReflection
+    #       RuntimeReflection
+    class AbstractReflection
+      # Returns a new, unsaved instance of the associated class. +attributes+ will
+      # be passed to the class's constructor.
+      def build_association(attributes, &block)
+        klass.new(attributes, &block)
+      end
+
+      # Returns the class name for the macro.
+      #
+      # <tt>composed_of :balance, class_name: 'Money'</tt> returns <tt>'Money'</tt>
+      # <tt>has_many :clients</tt> returns <tt>'Client'</tt>
+      def class_name
+        @class_name ||= (options[:class_name] || derive_class_name).to_s
+      end
+
+      def check_validity!
+        true
+      end
+
+      def alias_candidate(name)
+        "#{plural_name}_#{name}"
+      end
+    end
+
+    # Base class for AggregateReflection and AssociationReflection. Objects of
+    # AggregateReflection and AssociationReflection are returned by the Reflection::ClassMethods.
+    class MacroReflection < AbstractReflection
+      # Returns the name of the macro.
+      #
+      # <tt>composed_of :balance, class_name: 'Money'</tt> returns <tt>:balance</tt>
+      # <tt>has_many :clients</tt> returns <tt>:clients</tt>
+      attr_reader :name
+
+      attr_reader :scope
+
+      # Returns the hash of options used for the macro.
+      #
+      # <tt>composed_of :balance, class_name: 'Money'</tt> returns <tt>{ class_name: "Money" }</tt>
+      # <tt>has_many :clients</tt> returns <tt>{}</tt>
+      attr_reader :options
+
+      attr_reader :duck_record
+
+      attr_reader :plural_name # :nodoc:
+
+      def initialize(name, scope, options, duck_record)
+        @name          = name
+        @scope         = scope
+        @options       = options
+        @duck_record   = duck_record
+        @klass         = options[:anonymous_class]
+        @plural_name   = name.to_s.pluralize
+      end
+
+      # Returns the class for the macro.
+      #
+      # <tt>composed_of :balance, class_name: 'Money'</tt> returns the Money class
+      # <tt>has_many :clients</tt> returns the Client class
+      def klass
+        @klass ||= compute_class(class_name)
+      end
+
+      def compute_class(name)
+        name.constantize
+      end
+
+      # Returns +true+ if +self+ and +other_aggregation+ have the same +name+ attribute, +active_record+ attribute,
+      # and +other_aggregation+ has an options hash assigned to it.
+      def ==(other_aggregation)
+        super ||
+          other_aggregation.kind_of?(self.class) &&
+            name == other_aggregation.name &&
+            !other_aggregation.options.nil? &&
+            active_record == other_aggregation.active_record
+      end
+
+      private
+
+        def derive_class_name
+          name.to_s.camelize
+        end
+    end
+
+    # Holds all the metadata about an association as it was specified in the
+    # Active Record class.
+    class EmbedsAssociationReflection < MacroReflection
+      # Returns the target association's class.
+      #
+      #   class Author < ActiveRecord::Base
+      #     has_many :books
+      #   end
+      #
+      #   Author.reflect_on_association(:books).klass
+      #   # => Book
+      #
+      # <b>Note:</b> Do not call +klass.new+ or +klass.create+ to instantiate
+      # a new association object. Use +build_association+ or +create_association+
+      # instead. This allows plugins to hook into association object creation.
+      def klass
+        @klass ||= compute_class(class_name)
+      end
+
+      def compute_class(name)
+        duck_record.send(:compute_type, name)
+      end
+
+      attr_accessor :parent_reflection # Reflection
+
+      def initialize(name, scope, options, duck_record)
+        super
+        @constructable = calculate_constructable(macro, options)
+
+        if options[:class_name] && options[:class_name].class == Class
+          ActiveSupport::Deprecation.warn(<<-MSG.squish)
+            Passing a class to the `class_name` is deprecated and will raise
+            an ArgumentError in Rails 5.2. It eagerloads more classes than
+            necessary and potentially creates circular dependencies.
+
+            Please pass the class name as a string:
+            `#{macro} :#{name}, class_name: '#{options[:class_name]}'`
+          MSG
+        end
+      end
+
+      def constructable? # :nodoc:
+        @constructable
+      end
+
+      def source_reflection
+        self
+      end
+
+      def nested?
+        false
+      end
+
+      # Returns the macro type.
+      #
+      # <tt>has_many :clients</tt> returns <tt>:has_many</tt>
+      def macro; raise NotImplementedError; end
+
+      # Returns whether or not this association reflection is for a collection
+      # association. Returns +true+ if the +macro+ is either +has_many+ or
+      # +has_and_belongs_to_many+, +false+ otherwise.
+      def collection?
+        false
+      end
+
+      # Returns whether or not the association should be validated as part of
+      # the parent's validation.
+      #
+      # Unless you explicitly disable validation with
+      # <tt>validate: false</tt>, validation will take place when:
+      #
+      # * you explicitly enable validation; <tt>validate: true</tt>
+      # * you use autosave; <tt>autosave: true</tt>
+      # * the association is a +has_many+ association
+      def validate?
+        !options[:validate].nil? ? options[:validate] : collection?
+      end
+
+      # Returns +true+ if +self+ is a +has_one+ reflection.
+      def has_one?; false; end
+
+      def association_class; raise NotImplementedError; end
+
+      def add_as_source(seed)
+        seed
+      end
+
+      protected
+
+        def actual_source_reflection # FIXME: this is a horrible name
+          self
+        end
+
+      private
+
+        def calculate_constructable(macro, options)
+          true
+        end
+
+        def derive_class_name
+          class_name = name.to_s
+          class_name = class_name.singularize if collection?
+          class_name.camelize
+        end
+    end
+
+    class EmbedsManyReflection < EmbedsAssociationReflection
+      def macro; :embeds_many; end
+
+      def collection?; true; end
+
+      def association_class
+        Associations::EmbedsManyAssociation
+      end
+    end
+
+    class EmbedsOneReflection < EmbedsAssociationReflection
+      def macro; :embeds_one; end
+
+      def has_one?; true; end
+
+      def association_class
+        Associations::EmbedsOneAssociation
+      end
+    end
+
+    # Holds all the metadata about an association as it was specified in the
+    # Active Record class.
+    class AssociationReflection < MacroReflection
+      alias active_record duck_record
+
+      def quoted_table_name
+        klass.quoted_table_name
+      end
+
+      def primary_key_type
+        klass.type_for_attribute(klass.primary_key)
+      end
+
+      JoinKeys = Struct.new(:key, :foreign_key) # :nodoc:
+
+      def join_keys
+        get_join_keys klass
+      end
+
+      # Returns a list of scopes that should be applied for this Reflection
+      # object when querying the database.
+      def scopes
+        scope ? [scope] : []
+      end
+
+      def scope_chain
+        chain.map(&:scopes)
+      end
+      deprecate :scope_chain
+
+      def join_scopes(table, predicate_builder) # :nodoc:
+        if scope
+          [ActiveRecord::Relation.create(klass, table, predicate_builder)
+             .instance_exec(&scope)]
+        else
+          []
+        end
+      end
+
+      def klass_join_scope(table, predicate_builder) # :nodoc:
+        relation = ActiveRecord::Relation.create(klass, table, predicate_builder)
+        klass.scope_for_association(relation)
+      end
+
+      def constraints
+        chain.map(&:scopes).flatten
+      end
+
+      def alias_candidate(name)
+        "#{plural_name}_#{name}"
+      end
+
+      def chain
+        collect_join_chain
+      end
+
+      def get_join_keys(association_klass)
+        JoinKeys.new(join_pk(association_klass), join_fk)
+      end
+
+      # Returns the target association's class.
+      #
+      #   class Author < ActiveRecord::Base
+      #     has_many :books
+      #   end
+      #
+      #   Author.reflect_on_association(:books).klass
+      #   # => Book
+      #
+      # <b>Note:</b> Do not call +klass.new+ or +klass.create+ to instantiate
+      # a new association object. Use +build_association+ or +create_association+
+      # instead. This allows plugins to hook into association object creation.
+      def klass
+        @klass ||= compute_class(class_name)
+      end
+
+      def compute_class(name)
+        active_record.send(:compute_type, name)
+      end
+
+      def table_name
+        klass.table_name
+      end
+
+      attr_reader :type, :foreign_type
+      attr_accessor :parent_reflection # Reflection
+
+      def initialize(name, scope, options, active_record)
+        super
+        @type         = options[:as] && (options[:foreign_type] || "#{options[:as]}_type")
+        @foreign_type = options[:foreign_type] || "#{name}_type"
+        @constructable = calculate_constructable(macro, options)
+        @association_scope_cache = {}
+        @scope_lock = Mutex.new
+
+        if options[:class_name] && options[:class_name].class == Class
+          ActiveSupport::Deprecation.warn(<<-MSG.squish)
+            Passing a class to the `class_name` is deprecated and will raise
+            an ArgumentError in Rails 5.2. It eagerloads more classes than
+            necessary and potentially creates circular dependencies.
+
+            Please pass the class name as a string:
+            `#{macro} :#{name}, class_name: '#{options[:class_name]}'`
+          MSG
+        end
+      end
+
+      def association_scope_cache(conn, owner)
+        key = conn.prepared_statements
+        @association_scope_cache[key] ||= @scope_lock.synchronize {
+          @association_scope_cache[key] ||= yield
+        }
+      end
+
+      def constructable? # :nodoc:
+        @constructable
+      end
+
+      def join_table
+        @join_table ||= options[:join_table] || derive_join_table
+      end
+
+      def foreign_key
+        @foreign_key ||= options[:foreign_key] || derive_foreign_key.freeze
+      end
+
+      def association_foreign_key
+        @association_foreign_key ||= options[:association_foreign_key] || class_name.foreign_key
+      end
+
+      # klass option is necessary to support loading polymorphic associations
+      def association_primary_key(klass = nil)
+        options[:primary_key] || primary_key(klass || self.klass)
+      end
+
+      def association_primary_key_type
+        klass.type_for_attribute(association_primary_key.to_s)
+      end
+
+      def active_record_primary_key
+        @active_record_primary_key ||= options[:primary_key] || primary_key(active_record)
+      end
+
+      def check_validity!
+        unless klass < ActiveRecord::Base
+          raise ArgumentError, "#{klass} must be inherited from ActiveRecord::Base."
+        end
+      end
+
+      def check_preloadable!
+        return unless scope
+
+        if scope.arity > 0
+          raise ArgumentError, <<-MSG.squish
+            The association scope '#{name}' is instance dependent (the scope
+            block takes an argument). Preloading instance dependent scopes is
+            not supported.
+          MSG
+        end
+      end
+      alias :check_eager_loadable! :check_preloadable!
+
+      def join_id_for(owner) # :nodoc:
+        owner[active_record_primary_key]
+      end
+
+      def source_reflection
+        self
+      end
+
+      # A chain of reflections from this one back to the owner. For more see the explanation in
+      # ThroughReflection.
+      def collect_join_chain
+        [self]
+      end
+
+      # This is for clearing cache on the reflection. Useful for tests that need to compare
+      # SQL queries on associations.
+      def clear_association_scope_cache # :nodoc:
+        @association_scope_cache.clear
+      end
+
+      def nested?
+        false
+      end
+
+      def has_scope?
+        scope
+      end
+
+      # Returns the macro type.
+      #
+      # <tt>has_many :clients</tt> returns <tt>:has_many</tt>
+      def macro; raise NotImplementedError; end
+
+      # Returns whether or not this association reflection is for a collection
+      # association. Returns +true+ if the +macro+ is either +has_many+ or
+      # +has_and_belongs_to_many+, +false+ otherwise.
+      def collection?
+        false
+      end
+
+      # Returns whether or not the association should be validated as part of
+      # the parent's validation.
+      #
+      # Unless you explicitly disable validation with
+      # <tt>validate: false</tt>, validation will take place when:
+      #
+      # * you explicitly enable validation; <tt>validate: true</tt>
+      # * you use autosave; <tt>autosave: true</tt>
+      # * the association is a +has_many+ association
+      def validate?
+        !options[:validate].nil? ? options[:validate] : (options[:autosave] == true || collection?)
+      end
+
+      # Returns +true+ if +self+ is a +belongs_to+ reflection.
+      def belongs_to?; false; end
+
+      # Returns +true+ if +self+ is a +has_one+ reflection.
+      def has_one?; false; end
+
+      def association_class; raise NotImplementedError; end
+
+      def add_as_source(seed)
+        seed
+      end
+
+      def extensions
+        Array(options[:extend])
+      end
+
+      protected
+
+      def actual_source_reflection # FIXME: this is a horrible name
+        self
+      end
+
+      private
+
+      def join_pk(_)
+        foreign_key
+      end
+
+      def join_fk
+        active_record_primary_key
+      end
+
+      def calculate_constructable(_macro, _options)
+        false
+      end
+
+      def derive_class_name
+        class_name = name.to_s
+        class_name = class_name.singularize if collection?
+        class_name.camelize
+      end
+
+      def derive_foreign_key
+        if options[:as]
+          "#{options[:as]}_id"
+        else
+          "#{name}_id"
+        end
+      end
+
+      def primary_key(klass)
+        klass.primary_key || raise(ActiveRecord::UnknownPrimaryKey.new(klass))
+      end
+    end
+
+    class BelongsToReflection < AssociationReflection # :nodoc:
+      def macro; :belongs_to; end
+
+      def belongs_to?; true; end
+
+      def association_class
+        Associations::BelongsToAssociation
+      end
+
+      def join_id_for(owner) # :nodoc:
+        owner[foreign_key]
+      end
+
+      private
+
+      def join_fk
+        foreign_key
+      end
+
+      def join_pk(_klass)
+        association_primary_key
+      end
+    end
+
+    class HasManyReflection < AssociationReflection # :nodoc:
+      def macro; :has_many; end
+
+      def collection?; true; end
+
+      def association_class
+        Associations::HasManyAssociation
+      end
+
+      def association_primary_key(klass = nil)
+        primary_key(klass || self.klass)
+      end
+    end
+
+    class HasOneReflection < AssociationReflection # :nodoc:
+      def macro; :has_one; end
+
+      def has_one?; true; end
+
+      def association_class
+        Associations::HasOneAssociation
+      end
+    end
+  end
+end