ocean-dynamo 0.4.1 → 0.4.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d067b77a882722c6a949672647c910338812ccf7
-  data.tar.gz: 48f95744f784e8cef31a65fe496c9d69737521f8
+  metadata.gz: a28d5f280ebcb046fad6b812a8a4394ca2b64dfc
+  data.tar.gz: fc0f313738efd5370163056bf2915b83645f53b7
 SHA512:
-  metadata.gz: 8e46bbfcce5105eef9737075b4042c049472ecb06bb7b938503d920a176083ffbeb0c281a4eba79698d34de7e3bec5c8483a4f8a7ca4f6dd9ee1df880fea24f3
-  data.tar.gz: c519f71fea7afc08ebfe2496c13cec6f3292ada38e51dc15893396005ae70ec29694d0dcfd9702a92a36b99f6c4e614f2b14a7a90b1d639b60ee874bc0f26a3c
+  metadata.gz: 0259caaebfa02274f8103695c741670d6190be669ecd1c0d92d8165ea1a058f628ae96072c946fc77fc6561a0d7bb1ba075c0773201e6d3f641a69bdfec1b70b
+  data.tar.gz: 2b0108bbef441a611ebdaed44b76512b7ae62d75491fe0788d30f2d0ea1d5f0e80fa08a3c6a10547197d2f2640db9f7970f15e3e9e126c10ffbf778e4692b2ea

data/README.rdoc

@@ -10,11 +10,11 @@ OceanDynamo requires Ruby 2.0 and Ruby on Rails 4.0.0 or later.
 
 === Features
 
-As one important use case for OceanDynamo is to facilitate the conversion of SQL based
-ActiveRecord models to DynamoDB based models, it is important that the syntax and semantics
-of OceanDynamo's operations are as close as possible to those of ActiveRecord, including
-callbacks, exceptions and support methods. Ocean-dynamo follows this pattern closely and
-is of course based on ActiveModel.
+As one important use case for OceanDynamo is to facilitate the conversion of SQL
+databases to no-SQL DynamoDB databases, it is important that the syntax and semantics
+of OceanDynamo are as close as possible to those of ActiveRecord. This includes
+callbacks, exceptions and method chaining semantics. OceanDynamo follows this pattern 
+closely and is of course based on ActiveModel.
 
 The attribute and persistence layer of OceanDynamo is modeled on that of ActiveRecord:
 there's +save+, +save!+, +create+, +update+, +update!+, +update_attributes+, +find_each+,
@@ -23,9 +23,8 @@ is always to implement as much of the ActiveRecord interface as possible, withou
 compromising scalability. This makes the task of switching from SQL to no-SQL much easier.
 
 Thanks to its structural similarity to ActiveRecord, OceanDynamo works with FactoryGirl.
-To facilitate testing, future versions will keep track of and delete instances after tests.
 
-OceanDynamo uses primary indices to retrieve related table items, 
+OceanDynamo uses only primary indices to retrieve related table items and collections, 
 which means it will scale without limits.
 
 === Example
@@ -38,7 +37,7 @@ The following example shows the basic syntax for declaring a DynamoDB-based sche
 
     dynamo_schema(:uuid) do
       attribute :credentials,          :string
-      attribute :token
+      attribute :token,                :string,     default: Proc { SecureRandom.uuid }
       attribute :steps,                :serialized, default: []
       attribute :max_seconds_in_queue, :integer,    default: 1.day
       attribute :default_poison_limit, :integer,    default: 5
@@ -61,7 +60,7 @@ The following example shows the basic syntax for declaring a DynamoDB-based sche
 Each attribute has a name, a type (+:string+, +:integer+, +:float+, +:datetime+, +:boolean+, 
 or +:serialized+) where +:string+ is the default. Each attribute also optionally has a default 
 value, which can be a Proc. The hash key attribute is by default +:id+ (overridden as +:uuid+ in
-the example above) and is a +:string+. The keys can also be explicitly declared.
+the example above) and is a +:string+.
 
 The +:string+, +:integer+, +:float+ and +:datetime+ types can also store sets of their type.
 Sets are represented as arrays, may not contain duplicates and may not be empty.
@@ -84,7 +83,7 @@ value will return the empty string, <tt>""</tt>.
    connect: :late,                         # true, :late, nil/false
    create: false,                          # If true, create the table if nonexistent
    locking: :lock_version,                 # The name of the lock attribute or nil/false
-   timestamps: [:created_at, :updated_at]  # An array of timestamp columns or nil/false
+   timestamps: [:created_at, :updated_at]  # A two-element array of timestamp columns, or nil/false
  ) do
    # Attribute definitions
    ...
@@ -97,6 +96,8 @@ value will return the empty string, <tt>""</tt>.
 
 The following example shows how to set up a +has_many+ / +belongs_to+ relation:
 
+ class Child < OceanDynamo::Table; end
+ 
  class Parent < OceanDynamo::Table
    dynamo_schema do
      attribute :this
@@ -105,8 +106,8 @@ The following example shows how to set up a +has_many+ / +belongs_to+ relation:
    end
    has_many :children
  end
-
-
+ 
+ 
  class Child < OceanDynamo::Table
    dynamo_schema(:uuid) do
      attribute :foo
@@ -126,6 +127,7 @@ Restrictions for +belongs_to+ tables:
 
 Restrictions for +has_many+ tables:
 * The +has_many+ table may not have a range key.
+* +has_many+ must be placed after the +dynamo_schema+ attribute block.
 
 These restrictions allow OceanDynamo to implement the +has_many+ / +belongs_to+ 
 relation in a very efficient and massively scalable way. 
@@ -147,9 +149,9 @@ and matching, the fact that the range key is a string can be used to implement
 wildcard matching of additional attributes. This gives, amongst other things, the 
 equivalent of an SQL GROUP BY request, again without requiring any secondary indices.
 
-It's our goal to use a similar technique to implement has_and_belongs_to_many relations, 
+It's our goal to use a similar technique to implement +has_and_belongs_to_many+ relations, 
 which means that secondary indices won't be necessary for the vast majority of 
-OceanDynamo use cases. This ultimately means reduced operational costs, as well as
+DynamoDB tables. This ultimately means reduced operational costs, as well as
 reduced complexity.
 
 
@@ -158,22 +160,18 @@ reduced complexity.
 OceanDynamo is fully usable as an ActiveModel and can be used by Rails
 controllers. OceanDynamo implements much of the infrastructure of ActiveRecord;
 for instance, +read_attribute+, +write_attribute+, and much of the control logic and
-parameters.
-
-* has_many now works, in a minimalistic fashion. To implement the rest of the interface,
-  we need association proxies.
+internal organisation.
 
-* Instances of classes with one or more has_many relations now save all relations after
-  the instance has been saved. To save only dirty association collections, we need
-  association proxies. Collections which are nil are not saved. Collections which are []
-  are saved, which means they clear all children. This difference is crucial, until we
-  get association proxies.
+* +belongs_to+ now handles setting and retrieving the parent association correctly in
+  all cases, including direct and mass assignment (+:master+, +:master_id+, etc). 
+* +has_many=+ now destroys rather than deletes.
+* Got rid of the +fake_dynamo+ purge message.
+* Relations now take an optional reload arg, as in <tt>parent.children(true)</tt>.
 
-* #reload clears all relations.
 
 === Future milestones
 
-* Association proxies, to implement the same kind of interace as ActiveRecord, e.g.: 
+* Association proxies, to implement ActiveRecord-style method chaining, e.g.: 
   <code>blog_entry.comments.build(body: "Cool!").save!</code>
 
 * The +has_and_belongs_to_many+ assocation. 
@@ -184,7 +182,7 @@ parameters.
 === Current use
 
 OceanDynamo is currently used in the Ocean framework (http://wiki.oceanframework.net)
-e.g. to implement critical job queues. It will be used increasingly as features are
+e.g. to implement highly scalable job queues. It will be used increasingly as features are
 added to OceanDynamo and will eventually replace all ActiveRecord tables in Ocean.
 
 

data/lib/ocean-dynamo/active_record_stuff/reflection.rb

@@ -0,0 +1,583 @@
+module ActiveRecord
+  # = Active Record Reflection
+  module Reflection # :nodoc:
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :reflections
+      self.reflections = {}
+    end
+
+    # Reflection enables to interrogate Active Record classes and objects
+    # about their associations and aggregations. This information can,
+    # for example, 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
+      def create_reflection(macro, name, scope, options, active_record)
+        case macro
+        when :has_many, :belongs_to, :has_one, :has_and_belongs_to_many
+          klass = options[:through] ? ThroughReflection : AssociationReflection
+          reflection = klass.new(macro, name, scope, options, active_record)
+        when :composed_of
+          reflection = AggregateReflection.new(macro, name, scope, options, active_record)
+        end
+
+        self.reflections = self.reflections.merge(name => reflection)
+        reflection
+      end
+
+      # Returns an array of AggregateReflection objects for all the aggregations in the class.
+      def reflect_on_all_aggregations
+        reflections.values.grep(AggregateReflection)
+      end
+
+      # Returns the AggregateReflection object for the named +aggregation+ (use the symbol).
+      #
+      #   Account.reflect_on_aggregation(:balance) # => the balance AggregateReflection
+      #
+      def reflect_on_aggregation(aggregation)
+        reflection = reflections[aggregation]
+        reflection if reflection.is_a?(AggregateReflection)
+      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.grep(AssociationReflection)
+        macro ? association_reflections.select { |reflection| reflection.macro == 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)
+        reflection = reflections[association]
+        reflection if reflection.is_a?(AssociationReflection)
+      end
+
+      # Returns an array of AssociationReflection objects for all associations which have <tt>:autosave</tt> enabled.
+      def reflect_on_all_autosave_associations
+        reflections.values.select { |reflection| reflection.options[:autosave] }
+      end
+    end
+
+    # Base class for AggregateReflection and AssociationReflection. Objects of
+    # AggregateReflection and AssociationReflection are returned by the Reflection::ClassMethods.
+    #
+    #   MacroReflection
+    #     AggregateReflection
+    #     AssociationReflection
+    #       ThroughReflection
+    class MacroReflection
+      # 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
+
+      # Returns the macro type.
+      #
+      # <tt>composed_of :balance, class_name: 'Money'</tt> returns <tt>:composed_of</tt>
+      # <tt>has_many :clients</tt> returns <tt>:has_many</tt>
+      attr_reader :macro
+
+      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 +{}+
+      attr_reader :options
+
+      attr_reader :active_record
+
+      attr_reader :plural_name # :nodoc:
+
+      def initialize(macro, name, scope, options, active_record)
+        @macro         = macro
+        @name          = name
+        @scope         = scope
+        @options       = options
+        @active_record = active_record
+        @plural_name   = active_record.pluralize_table_names ?
+                            name.to_s.pluralize : name.to_s
+      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 ||= class_name.constantize
+      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
+
+      # 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 &&
+          active_record == other_aggregation.active_record
+      end
+
+      private
+        def derive_class_name
+          name.to_s.camelize
+        end
+    end
+
+
+    # Holds all the meta-data about an aggregation as it was specified in the
+    # Active Record class.
+    class AggregateReflection < MacroReflection #:nodoc:
+      def mapping
+        mapping = options[:mapping] || [name, name]
+        mapping.first.is_a?(Array) ? mapping : [mapping]
+      end
+    end
+
+    # Holds all the meta-data about an association as it was specified in the
+    # Active Record class.
+    class AssociationReflection < MacroReflection #:nodoc:
+      # 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 ||= active_record.send(:compute_type, class_name)
+      end
+
+      def initialize(*args)
+        super
+        @collection = [:has_many, :has_and_belongs_to_many].include?(macro)
+      end
+
+      # 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
+
+      def table_name
+        @table_name ||= klass.table_name
+      end
+
+      def quoted_table_name
+        @quoted_table_name ||= klass.quoted_table_name
+      end
+
+      def join_table
+        @join_table ||= options[:join_table] || derive_join_table
+      end
+
+      def foreign_key
+        @foreign_key ||= options[:foreign_key] || derive_foreign_key
+      end
+
+      def foreign_type
+        @foreign_type ||= options[:foreign_type] || "#{name}_type"
+      end
+
+      def type
+        @type ||= options[:as] && "#{options[:as]}_type"
+      end
+
+      def primary_key_column
+        @primary_key_column ||= klass.columns.find { |c| c.name == klass.primary_key }
+      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 active_record_primary_key
+        @active_record_primary_key ||= options[:primary_key] || primary_key(active_record)
+      end
+
+      def counter_cache_column
+        if options[:counter_cache] == true
+          "#{active_record.name.demodulize.underscore.pluralize}_count"
+        elsif options[:counter_cache]
+          options[:counter_cache].to_s
+        end
+      end
+
+      def columns(tbl_name)
+        @columns ||= klass.connection.columns(tbl_name)
+      end
+
+      def reset_column_information
+        @columns = nil
+      end
+
+      def check_validity!
+        check_validity_of_inverse!
+
+        if has_and_belongs_to_many? && association_foreign_key == foreign_key
+          raise HasAndBelongsToManyAssociationForeignKeyNeeded.new(self)
+        end
+      end
+
+      def check_validity_of_inverse!
+        unless options[:polymorphic]
+          if has_inverse? && inverse_of.nil?
+            raise InverseOfAssociationNotFoundError.new(self)
+          end
+        end
+      end
+
+      def through_reflection
+        nil
+      end
+
+      def source_reflection
+        nil
+      end
+
+      # A chain of reflections from this one back to the owner. For more see the explanation in
+      # ThroughReflection.
+      def chain
+        [self]
+      end
+
+      def nested?
+        false
+      end
+
+      # An array of arrays of scopes. Each item in the outside array corresponds to a reflection
+      # in the #chain.
+      def scope_chain
+        scope ? [[scope]] : [[]]
+      end
+
+      alias :source_macro :macro
+
+      def has_inverse?
+        @options[:inverse_of]
+      end
+
+      def inverse_of
+        if has_inverse?
+          @inverse_of ||= klass.reflect_on_association(options[:inverse_of])
+        end
+      end
+
+      def polymorphic_inverse_of(associated_class)
+        if has_inverse?
+          if inverse_relationship = associated_class.reflect_on_association(options[:inverse_of])
+            inverse_relationship
+          else
+            raise InverseOfAssociationNotFoundError.new(self, associated_class)
+          end
+        end
+      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?
+        @collection
+      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 || macro == :has_many)
+      end
+
+      # Returns +true+ if +self+ is a +belongs_to+ reflection.
+      def belongs_to?
+        macro == :belongs_to
+      end
+
+      def has_and_belongs_to_many?
+        macro == :has_and_belongs_to_many
+      end
+
+      def association_class
+        case macro
+        when :belongs_to
+          if options[:polymorphic]
+            Associations::BelongsToPolymorphicAssociation
+          else
+            Associations::BelongsToAssociation
+          end
+        when :has_and_belongs_to_many
+          Associations::HasAndBelongsToManyAssociation
+        when :has_many
+          if options[:through]
+            Associations::HasManyThroughAssociation
+          else
+            Associations::HasManyAssociation
+          end
+        when :has_one
+          if options[:through]
+            Associations::HasOneThroughAssociation
+          else
+            Associations::HasOneAssociation
+          end
+        end
+      end
+
+      def polymorphic?
+        options.key? :polymorphic
+      end
+
+      private
+        def derive_class_name
+          class_name = name.to_s.camelize
+          class_name = class_name.singularize if collection?
+          class_name
+        end
+
+        def derive_foreign_key
+          if belongs_to?
+            "#{name}_id"
+          elsif options[:as]
+            "#{options[:as]}_id"
+          else
+            active_record.name.foreign_key
+          end
+        end
+
+        def derive_join_table
+          [active_record.table_name, klass.table_name].sort.join("\0").gsub(/^(.*_)(.+)\0\1(.+)/, '\1\2_\3').gsub("\0", "_")
+        end
+
+        def primary_key(klass)
+          klass.primary_key || raise(UnknownPrimaryKey.new(klass))
+        end
+    end
+
+    # Holds all the meta-data about a :through association as it was specified
+    # in the Active Record class.
+    class ThroughReflection < AssociationReflection #:nodoc:
+      delegate :foreign_key, :foreign_type, :association_foreign_key,
+               :active_record_primary_key, :type, :to => :source_reflection
+
+      # Gets the source of the through reflection. It checks both a singularized
+      # and pluralized form for <tt>:belongs_to</tt> or <tt>:has_many</tt>.
+      #
+      #   class Post < ActiveRecord::Base
+      #     has_many :taggings
+      #     has_many :tags, through: :taggings
+      #   end
+      #
+      #   class Tagging < ActiveRecord::Base
+      #     belongs_to :post
+      #     belongs_to :tag
+      #   end
+      #
+      #   tags_reflection = Post.reflect_on_association(:tags)
+      #
+      #   taggings_reflection = tags_reflection.source_reflection
+      #   # => <ActiveRecord::Reflection::AssociationReflection: @macro=:belongs_to, @name=:tag, @active_record=Tagging, @plural_name="tags">
+      #
+      def source_reflection
+        @source_reflection ||= source_reflection_names.collect { |name| through_reflection.klass.reflect_on_association(name) }.compact.first
+      end
+
+      # Returns the AssociationReflection object specified in the <tt>:through</tt> option
+      # of a HasManyThrough or HasOneThrough association.
+      #
+      #   class Post < ActiveRecord::Base
+      #     has_many :taggings
+      #     has_many :tags, through: :taggings
+      #   end
+      #
+      #   tags_reflection = Post.reflect_on_association(:tags)
+      #   taggings_reflection = tags_reflection.through_reflection
+      #
+      def through_reflection
+        @through_reflection ||= active_record.reflect_on_association(options[:through])
+      end
+
+      # Returns an array of reflections which are involved in this association. Each item in the
+      # array corresponds to a table which will be part of the query for this association.
+      #
+      # The chain is built by recursively calling #chain on the source reflection and the through
+      # reflection. The base case for the recursion is a normal association, which just returns
+      # [self] as its #chain.
+      #
+      #   class Post < ActiveRecord::Base
+      #     has_many :taggings
+      #     has_many :tags, through: :taggings
+      #   end
+      #
+      #   tags_reflection = Post.reflect_on_association(:tags)
+      #   tags_reflection.chain
+      #   # => [<ActiveRecord::Reflection::ThroughReflection: @macro=:has_many, @name=:tags, @options={:through=>:taggings}, @active_record=Post>,
+      #         <ActiveRecord::Reflection::AssociationReflection: @macro=:has_many, @name=:taggings, @options={}, @active_record=Post>]
+      #
+      def chain
+        @chain ||= begin
+          chain = source_reflection.chain + through_reflection.chain
+          chain[0] = self # Use self so we don't lose the information from :source_type
+          chain
+        end
+      end
+
+      # Consider the following example:
+      #
+      #   class Person
+      #     has_many :articles
+      #     has_many :comment_tags, through: :articles
+      #   end
+      #
+      #   class Article
+      #     has_many :comments
+      #     has_many :comment_tags, through: :comments, source: :tags
+      #   end
+      #
+      #   class Comment
+      #     has_many :tags
+      #   end
+      #
+      # There may be scopes on Person.comment_tags, Article.comment_tags and/or Comment.tags,
+      # but only Comment.tags will be represented in the #chain. So this method creates an array
+      # of scopes corresponding to the chain.
+      def scope_chain
+        @scope_chain ||= begin
+          scope_chain = source_reflection.scope_chain.map(&:dup)
+
+          # Add to it the scope from this reflection (if any)
+          scope_chain.first << scope if scope
+
+          through_scope_chain = through_reflection.scope_chain
+
+          if options[:source_type]
+            through_scope_chain.first <<
+              through_reflection.klass.where(foreign_type => options[:source_type])
+          end
+
+          # Recursively fill out the rest of the array from the through reflection
+          scope_chain + through_scope_chain
+        end
+      end
+
+      # The macro used by the source association
+      def source_macro
+        source_reflection.source_macro
+      end
+
+      # A through association is nested if there would be more than one join table
+      def nested?
+        chain.length > 2 || through_reflection.macro == :has_and_belongs_to_many
+      end
+
+      # We want to use the klass from this reflection, rather than just delegate straight to
+      # the source_reflection, because the source_reflection may be polymorphic. We still
+      # need to respect the source_reflection's :primary_key option, though.
+      def association_primary_key(klass = nil)
+        # Get the "actual" source reflection if the immediate source reflection has a
+        # source reflection itself
+        source_reflection = self.source_reflection
+        while source_reflection.source_reflection
+          source_reflection = source_reflection.source_reflection
+        end
+
+        source_reflection.options[:primary_key] || primary_key(klass || self.klass)
+      end
+
+      # Gets an array of possible <tt>:through</tt> source reflection names in both singular and plural form.
+      #
+      #   class Post < ActiveRecord::Base
+      #     has_many :taggings
+      #     has_many :tags, through: :taggings
+      #   end
+      #
+      #   tags_reflection = Post.reflect_on_association(:tags)
+      #   tags_reflection.source_reflection_names
+      #   # => [:tag, :tags]
+      #
+      def source_reflection_names
+        @source_reflection_names ||= (options[:source] ? [options[:source]] : [name.to_s.singularize, name]).collect { |n| n.to_sym }
+      end
+
+      def source_options
+        source_reflection.options
+      end
+
+      def through_options
+        through_reflection.options
+      end
+
+      def check_validity!
+        if through_reflection.nil?
+          raise HasManyThroughAssociationNotFoundError.new(active_record.name, self)
+        end
+
+        if through_reflection.options[:polymorphic]
+          raise HasManyThroughAssociationPolymorphicThroughError.new(active_record.name, self)
+        end
+
+        if source_reflection.nil?
+          raise HasManyThroughSourceAssociationNotFoundError.new(self)
+        end
+
+        if options[:source_type] && source_reflection.options[:polymorphic].nil?
+          raise HasManyThroughAssociationPointlessSourceTypeError.new(active_record.name, self, source_reflection)
+        end
+
+        if source_reflection.options[:polymorphic] && options[:source_type].nil?
+          raise HasManyThroughAssociationPolymorphicSourceError.new(active_record.name, self, source_reflection)
+        end
+
+        if macro == :has_one && through_reflection.collection?
+          raise HasOneThroughCantAssociateThroughCollection.new(active_record.name, self, through_reflection)
+        end
+
+        check_validity_of_inverse!
+      end
+
+      private
+        def derive_class_name
+          # get the class_name of the belongs_to association of the through reflection
+          options[:source_type] || source_reflection.class_name
+        end
+    end
+  end
+end