inverse_of 0.0.1 → 0.1.0

data/CHANGELOG

@@ -0,0 +1,8 @@
+== 0.1.0 2011-08-31
+
+ * Fix bug with eager loading.
+ * Require AR < 2.3.6.
+
+== 0.0.1 2010-02-05
+
+ * Hi.

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2009 George Ogata
+Copyright (c) 2009-2010 George Ogata
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/Rakefile

@@ -1,38 +1 @@
-require 'rubygems'
-require 'rake'
-
-begin
-  require 'jeweler'
-  Jeweler::Tasks.new do |gem|
-    gem.name = "inverse_of"
-    gem.summary = "Backport of ActiveRecord 2.3.6's inverse associations."
-    gem.description = "Backport of ActiveRecord 2.3.6's inverse associations."
-    gem.email = "george.ogata@gmail.com"
-    gem.homepage = "http://github.com/oggy/inverse_of"
-    gem.authors = ["George Ogata"]
-  end
-  Jeweler::GemcutterTasks.new
-rescue LoadError
-  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
-end
-
-require 'rake/testtask'
-
-desc "Run the test/unit tests for inverse associations, backported from ActiveRecord 2.3.6."
-Rake::TestTask.new(:test => :check_dependencies) do |test|
-  test.libs << 'lib' << 'test'
-  test.pattern = 'test/**/*_test.rb'
-  test.verbose = true
-end
-
-task :default => :test
-
-require 'rake/rdoctask'
-Rake::RDocTask.new do |rdoc|
-  version = File.exist?('VERSION') ? File.read('VERSION') : ""
-
-  rdoc.rdoc_dir = 'rdoc'
-  rdoc.title = "inverse_of #{version}"
-  rdoc.rdoc_files.include('README*')
-  rdoc.rdoc_files.include('lib/**/*.rb')
-end
+require 'ritual'

data/lib/inverse_of.rb

@@ -1,293 +1,292 @@
-if ([ActiveRecord::VERSION::MAJOR, ActiveRecord::VERSION::MINOR, ActiveRecord::VERSION::TINY] <=> [2, 3, 6]) < 0
-  module InverseOf
-    class InverseOfAssociationNotFoundError < ActiveRecord::ActiveRecordError #:nodoc:
-      def initialize(reflection, associated_class = nil)
-        super("Could not find the inverse association for #{reflection.name} (#{reflection.options[:inverse_of].inspect} in #{associated_class.nil? ? reflection.class_name : associated_class.name})")
-      end
+module InverseOf
+  class InverseOfAssociationNotFoundError < ActiveRecord::ActiveRecordError #:nodoc:
+    def initialize(reflection, associated_class = nil)
+      super("Could not find the inverse association for #{reflection.name} (#{reflection.options[:inverse_of].inspect} in #{associated_class.nil? ? reflection.class_name : associated_class.name})")
+    end
+  end
+
+  module Reflection
+    def self.included(base)
+      base::AssociationReflection.send :include, AssociationReflection
+      base::ThroughReflection.send :include, ThroughReflection
     end
 
-    module Reflection
+    module AssociationReflection
       def self.included(base)
-        base::AssociationReflection.send :include, AssociationReflection
-        base::ThroughReflection.send :include, ThroughReflection
+        base.alias_method_chain :check_validity!, :inverse_of
       end
 
-      module AssociationReflection
-        def self.included(base)
-          base.alias_method_chain :check_validity!, :inverse_of
-        end
-
-        def check_validity_with_inverse_of!
-          check_validity_of_inverse!
-          check_validity_without_inverse_of!
-        end
+      def check_validity_with_inverse_of!
+        check_validity_of_inverse!
+        check_validity_without_inverse_of!
+      end
 
-        def check_validity_of_inverse!
-          unless options[:polymorphic]
-            if has_inverse? && inverse_of.nil?
-              raise InverseOfAssociationNotFoundError.new(self)
-            end
+      def check_validity_of_inverse!
+        unless options[:polymorphic]
+          if has_inverse? && inverse_of.nil?
+            raise InverseOfAssociationNotFoundError.new(self)
           end
         end
+      end
 
-        def has_inverse?
-          !@options[:inverse_of].nil?
-        end
+      def has_inverse?
+        !@options[:inverse_of].nil?
+      end
 
-        def inverse_of
-          if has_inverse?
-            @inverse_of ||= klass.reflect_on_association(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
+      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
+    end
 
-      module ThroughReflection
-        def self.included(base)
-          base.alias_method_chain :check_validity!, :inverse_of
-        end
+    module ThroughReflection
+      def self.included(base)
+        base.alias_method_chain :check_validity!, :inverse_of
+      end
 
-        def check_validity_with_inverse_of!
-          check_validity_of_inverse!
-          check_validity_without_inverse_of!
-        end
+      def check_validity_with_inverse_of!
+        check_validity_of_inverse!
+        check_validity_without_inverse_of!
       end
     end
+  end
 
-    module Associations
-      module AssociationCollection
-        def self.included(base)
-          base.alias_method_chain :find_target, :inverse_of
-          base.alias_method_chain :add_record_to_target_with_callbacks, :inverse_of
-        end
-
-        def find_target_with_inverse_of
-          records = find_target_without_inverse_of
-          records.each do |record|
-            set_inverse_instance(record, @owner)
-          end
-          records
-        end
+  module Associations
+    module AssociationCollection
+      def self.included(base)
+        base.alias_method_chain :find_target, :inverse_of
+        base.alias_method_chain :add_record_to_target_with_callbacks, :inverse_of
+      end
 
-        def add_record_to_target_with_callbacks_with_inverse_of(record, &block)
-          record = add_record_to_target_with_callbacks_without_inverse_of(record, &block)
+      def find_target_with_inverse_of
+        records = find_target_without_inverse_of
+        records.each do |record|
           set_inverse_instance(record, @owner)
-          record
         end
+        records
       end
 
-      module AssociationProxy
-        def self.included(base)
-          base.alias_method_chain :initialize, :inverse_of
-        end
+      def add_record_to_target_with_callbacks_with_inverse_of(record, &block)
+        record = add_record_to_target_with_callbacks_without_inverse_of(record, &block)
+        set_inverse_instance(record, @owner)
+        record
+      end
+    end
 
-        def initialize_with_inverse_of(owner, reflection)
-          reflection.check_validity!
-          initialize_without_inverse_of(owner, reflection)
-        end
+    module AssociationProxy
+      def self.included(base)
+        base.alias_method_chain :initialize, :inverse_of
+      end
 
-        private
+      def initialize_with_inverse_of(owner, reflection)
+        reflection.check_validity!
+        initialize_without_inverse_of(owner, reflection)
+      end
 
-        def set_inverse_instance(record, instance)
-          return if record.nil? || !we_can_set_the_inverse_on_this?(record)
-          inverse_relationship = @reflection.inverse_of
-          unless inverse_relationship.nil?
-            record.send(:"set_#{inverse_relationship.name}_target", instance)
-          end
-        end
+      private
 
-        # Override in subclasses
-        def we_can_set_the_inverse_on_this?(record)
-          false
+      def set_inverse_instance(record, instance)
+        return if record.nil? || !we_can_set_the_inverse_on_this?(record)
+        inverse_relationship = @reflection.inverse_of
+        unless inverse_relationship.nil?
+          record.send(:"set_#{inverse_relationship.name}_target", instance)
         end
       end
 
-      module BelongsToAssociation
-        def self.included(base)
-          base.alias_method_chain :replace, :inverse_of
-          base.alias_method_chain :find_target, :inverse_of
-        end
+      # Override in subclasses
+      def we_can_set_the_inverse_on_this?(record)
+        false
+      end
+    end
 
-        def replace_with_inverse_of(record)
-          replace_without_inverse_of(record)
-          set_inverse_instance(record, @owner)
-          record
-        end
+    module BelongsToAssociation
+      def self.included(base)
+        base.alias_method_chain :replace, :inverse_of
+        base.alias_method_chain :find_target, :inverse_of
+      end
 
-        def find_target_with_inverse_of
-          target = find_target_without_inverse_of and
-            set_inverse_instance(target, @owner)
-          target
-        end
+      def replace_with_inverse_of(record)
+        replace_without_inverse_of(record)
+        set_inverse_instance(record, @owner)
+        record
+      end
 
-        # NOTE - for now, we're only supporting inverse setting from belongs_to back onto
-        # has_one associations.
-        def we_can_set_the_inverse_on_this?(record)
-          @reflection.has_inverse? && @reflection.inverse_of.macro == :has_one
-        end
+      def find_target_with_inverse_of
+        target = find_target_without_inverse_of and
+          set_inverse_instance(target, @owner)
+        target
       end
 
-      module BelongsToPolymorphicAssociation
-        def self.included(base)
-          base.alias_method_chain :replace, :inverse_of
-          base.alias_method_chain :find_target, :inverse_of
-        end
+      # NOTE - for now, we're only supporting inverse setting from belongs_to back onto
+      # has_one associations.
+      def we_can_set_the_inverse_on_this?(record)
+        @reflection.has_inverse? && @reflection.inverse_of.macro == :has_one
+      end
+    end
 
-        def replace_with_inverse_of(record)
-          replace_without_inverse_of(record)
-          set_inverse_instance(record, @owner)
-          record
-        end
+    module BelongsToPolymorphicAssociation
+      def self.included(base)
+        base.alias_method_chain :replace, :inverse_of
+        base.alias_method_chain :find_target, :inverse_of
+      end
 
-        def find_target_with_inverse_of
-          target = find_target_without_inverse_of
-          set_inverse_instance(target, @owner)
-          target
-        end
+      def replace_with_inverse_of(record)
+        replace_without_inverse_of(record)
+        set_inverse_instance(record, @owner)
+        record
+      end
 
-        # NOTE - for now, we're only supporting inverse setting from belongs_to back onto
-        # has_one associations.
-        def we_can_set_the_inverse_on_this?(record)
-          if @reflection.has_inverse?
-            inverse_association = @reflection.polymorphic_inverse_of(record.class)
-            inverse_association && inverse_association.macro == :has_one
-          else
-            false
-          end
-        end
+      def find_target_with_inverse_of
+        target = find_target_without_inverse_of
+        set_inverse_instance(target, @owner)
+        target
+      end
 
-        def set_inverse_instance(record, instance)
-          return if record.nil? || !we_can_set_the_inverse_on_this?(record)
-          inverse_relationship = @reflection.polymorphic_inverse_of(record.class)
-          unless inverse_relationship.nil?
-            record.send(:"set_#{inverse_relationship.name}_target", instance)
-          end
+      # NOTE - for now, we're only supporting inverse setting from belongs_to back onto
+      # has_one associations.
+      def we_can_set_the_inverse_on_this?(record)
+        if @reflection.has_inverse?
+          inverse_association = @reflection.polymorphic_inverse_of(record.class)
+          inverse_association && inverse_association.macro == :has_one
+        else
+          false
         end
       end
 
-      module HasManyAssociation
-        def we_can_set_the_inverse_on_this?(record)
-          inverse = @reflection.inverse_of
-          return !inverse.nil?
+      def set_inverse_instance(record, instance)
+        return if record.nil? || !we_can_set_the_inverse_on_this?(record)
+        inverse_relationship = @reflection.polymorphic_inverse_of(record.class)
+        unless inverse_relationship.nil?
+          record.send(:"set_#{inverse_relationship.name}_target", instance)
         end
       end
+    end
 
-      module HasManyThroughAssociation
-        def initialize(owner, reflection)
-          super
-        end
+    module HasManyAssociation
+      def we_can_set_the_inverse_on_this?(record)
+        inverse = @reflection.inverse_of
+        return !inverse.nil?
+      end
+    end
 
-        # NOTE - not sure that we can actually cope with inverses here
-        def we_can_set_the_inverse_on_this?(record)
-          false
-        end
+    module HasManyThroughAssociation
+      def initialize(owner, reflection)
+        super
       end
 
-      module HasOneAssociation
-        def self.included(base)
-          base.alias_method_chain :find_target, :inverse_of
-          base.alias_method_chain :new_record, :inverse_of
-          base.alias_method_chain :replace, :inverse_of
-        end
+      # NOTE - not sure that we can actually cope with inverses here
+      def we_can_set_the_inverse_on_this?(record)
+        false
+      end
+    end
 
-        def find_target_with_inverse_of
-          target = find_target_without_inverse_of
-          set_inverse_instance(target, @owner)
-          target
-        end
+    module HasOneAssociation
+      def self.included(base)
+        base.alias_method_chain :find_target, :inverse_of
+        base.alias_method_chain :new_record, :inverse_of
+        base.alias_method_chain :replace, :inverse_of
+      end
 
-        def replace_with_inverse_of(record, dont_save = false)
-          value = replace_without_inverse_of(record, dont_save)
-          set_inverse_instance(record, @owner)
-          value
-        end
+      def find_target_with_inverse_of
+        target = find_target_without_inverse_of
+        set_inverse_instance(target, @owner)
+        target
+      end
 
-        private
+      def replace_with_inverse_of(record, dont_save = false)
+        value = replace_without_inverse_of(record, dont_save)
+        set_inverse_instance(record, @owner)
+        value
+      end
 
-        def new_record_with_inverse_of(replace_existing, &block)
-          record = new_record_without_inverse_of(replace_existing, &block)
-          set_inverse_instance(record, @owner) unless replace_existing
-          record
-        end
+      private
 
-        def we_can_set_the_inverse_on_this?(record)
-          inverse = @reflection.inverse_of
-          return !inverse.nil?
-        end
+      def new_record_with_inverse_of(replace_existing, &block)
+        record = new_record_without_inverse_of(replace_existing, &block)
+        set_inverse_instance(record, @owner) unless replace_existing
+        record
       end
 
-      module ClassMethods
-        module JoinDependency
-          def self.included(base)
-            base.alias_method_chain :construct_association, :inverse_of
-          end
+      def we_can_set_the_inverse_on_this?(record)
+        inverse = @reflection.inverse_of
+        return !inverse.nil?
+      end
+    end
 
-          def construct_association_with_inverse_of(record, join, row)
-            association = construct_association_without_inverse_of(record, join, row) or
-              return nil
-            association_proxy = record.send(join.reflection.name)
-            association_proxy.__send__(:set_inverse_instance, association, record)
-          end
+    module ClassMethods
+      module JoinDependency
+        def self.included(base)
+          base.alias_method_chain :construct_association, :inverse_of
+        end
+
+        def construct_association_with_inverse_of(record, join, row)
+          association = construct_association_without_inverse_of(record, join, row) or
+            return nil
+          association_proxy = record.send(join.reflection.name)
+          association_proxy.__send__(:set_inverse_instance, association, record)
+          return association
         end
       end
     end
+  end
 
-    module AssociationPreload
-      def self.included(base)
-        base.extend ClassMethods
-        base.metaclass.alias_method_chain :add_preloaded_records_to_collection, :inverse_of
-        base.metaclass.alias_method_chain :set_association_single_records, :inverse_of
-      end
+  module AssociationPreload
+    def self.included(base)
+      base.extend ClassMethods
+      base.metaclass.alias_method_chain :add_preloaded_records_to_collection, :inverse_of
+      base.metaclass.alias_method_chain :set_association_single_records, :inverse_of
+    end
 
-      module ClassMethods
-        def add_preloaded_records_to_collection_with_inverse_of(parent_records, reflection_name, associated_record)
-          value = add_preloaded_records_to_collection_without_inverse_of(parent_records, reflection_name, associated_record)
-          parent_records.each do |parent_record|
-            association_proxy = parent_record.send(reflection_name)
-            association_proxy.__send__(:set_inverse_instance, associated_record, parent_record)
-          end
-          value
+    module ClassMethods
+      def add_preloaded_records_to_collection_with_inverse_of(parent_records, reflection_name, associated_record)
+        value = add_preloaded_records_to_collection_without_inverse_of(parent_records, reflection_name, associated_record)
+        parent_records.each do |parent_record|
+          association_proxy = parent_record.send(reflection_name)
+          association_proxy.__send__(:set_inverse_instance, associated_record, parent_record)
         end
+        value
+      end
 
-        def set_association_single_records_with_inverse_of(id_to_record_map, reflection_name, associated_records, key)
-          value = set_association_single_records_without_inverse_of(id_to_record_map, reflection_name, associated_records, key)
-          associated_records.each do |associated_record|
-            mapped_records = id_to_record_map[associated_record[key].to_s]
-            mapped_records.each do |mapped_record|
-              association_proxy = mapped_record.send(reflection_name)
-              association_proxy.__send__(:set_inverse_instance, associated_record, mapped_record)
-            end
+      def set_association_single_records_with_inverse_of(id_to_record_map, reflection_name, associated_records, key)
+        value = set_association_single_records_without_inverse_of(id_to_record_map, reflection_name, associated_records, key)
+        associated_records.each do |associated_record|
+          mapped_records = id_to_record_map[associated_record[key].to_s]
+          mapped_records.each do |mapped_record|
+            association_proxy = mapped_record.send(reflection_name)
+            association_proxy.__send__(:set_inverse_instance, associated_record, mapped_record)
           end
-          value
         end
+        value
       end
     end
   end
+end
 
-  ActiveRecord::InverseOfAssociationNotFoundError = InverseOf::InverseOfAssociationNotFoundError
-  ActiveRecord::Associations::AssociationCollection.send :include, InverseOf::Associations::AssociationCollection
-  ActiveRecord::Associations::AssociationProxy.send :include, InverseOf::Associations::AssociationProxy
-  ActiveRecord::Associations::BelongsToAssociation.send :include, InverseOf::Associations::BelongsToAssociation
-  ActiveRecord::Associations::BelongsToPolymorphicAssociation.send :include, InverseOf::Associations::BelongsToPolymorphicAssociation
-  ActiveRecord::Associations::HasManyAssociation.send :include, InverseOf::Associations::HasManyAssociation
-  ActiveRecord::Associations::HasManyThroughAssociation.send :include, InverseOf::Associations::HasManyThroughAssociation
-  ActiveRecord::Associations::HasOneAssociation.send :include, InverseOf::Associations::HasOneAssociation
-  ActiveRecord::Associations::ClassMethods::JoinDependency.send :include, InverseOf::Associations::ClassMethods::JoinDependency
-  ActiveRecord::Reflection.send :include, InverseOf::Reflection
-  ActiveRecord::Base.send :include, InverseOf::AssociationPreload
-
-  module ActiveRecord::Associations::ClassMethods
-    @@valid_keys_for_has_many_association << :inverse_of
-    @@valid_keys_for_has_one_association << :inverse_of
-    @@valid_keys_for_belongs_to_association << :inverse_of
-  end
+ActiveRecord::InverseOfAssociationNotFoundError = InverseOf::InverseOfAssociationNotFoundError
+ActiveRecord::Associations::AssociationCollection.send :include, InverseOf::Associations::AssociationCollection
+ActiveRecord::Associations::AssociationProxy.send :include, InverseOf::Associations::AssociationProxy
+ActiveRecord::Associations::BelongsToAssociation.send :include, InverseOf::Associations::BelongsToAssociation
+ActiveRecord::Associations::BelongsToPolymorphicAssociation.send :include, InverseOf::Associations::BelongsToPolymorphicAssociation
+ActiveRecord::Associations::HasManyAssociation.send :include, InverseOf::Associations::HasManyAssociation
+ActiveRecord::Associations::HasManyThroughAssociation.send :include, InverseOf::Associations::HasManyThroughAssociation
+ActiveRecord::Associations::HasOneAssociation.send :include, InverseOf::Associations::HasOneAssociation
+ActiveRecord::Associations::ClassMethods::JoinDependency.send :include, InverseOf::Associations::ClassMethods::JoinDependency
+ActiveRecord::Reflection.send :include, InverseOf::Reflection
+ActiveRecord::Base.send :include, InverseOf::AssociationPreload
+
+module ActiveRecord::Associations::ClassMethods
+  @@valid_keys_for_has_many_association << :inverse_of
+  @@valid_keys_for_has_one_association << :inverse_of
+  @@valid_keys_for_belongs_to_association << :inverse_of
 end