inverse_of 0.0.1

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,21 @@
+## MAC OS
+.DS_Store
+
+## TEXTMATE
+*.tmproj
+tmtags
+
+## EMACS
+*~
+\#*
+.\#*
+
+## VIM
+*.swp
+
+## PROJECT::GENERAL
+coverage
+rdoc
+pkg
+
+## PROJECT::SPECIFIC

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 George Ogata
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 [name of plugin creator]
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.markdown

@@ -0,0 +1,72 @@
+# Inverse Of
+
+Backport of ActiveRecord 2.3.6's inverse associations feature.
+
+    class Parent < ActiveRecord::Base
+      has_one :child, :inverse_of => :parent
+    end
+
+    class Child < ActiveRecord::Base
+      belongs_to :parent, :inverse_of => :child
+    end
+
+Now:
+
+    parent = Parent.first
+    parent.child.parent.equal?(parent)  # true
+
+Without inverse associations, the last line is false.  Although
+ActiveRecord does perform database query caching, you still suffer the
+overhead of creating unnecessary ActiveRecord objects.
+
+Inverse associations are also necessary to support validations on the
+parent which must fire before the parent is saved.  For example:
+
+    class Parent < ActiveRecord::Base
+      has_one :child
+      accepts_nested_attributes_for :child
+    end
+
+    class Child < ActiveRecord::Base
+      belongs_to :parent
+      validates_presence_of :parent_id
+    end
+
+    Parent.new(:child_attributes => {:name => 'child name'}).valid?
+
+Here, the parent object fails validation, because the parent_id is not
+set yet.  If inverses are declared, and the validation runs on the
+association rather than the ID, the validation passes.
+
+    class Parent < ActiveRecord::Base
+      has_one :child, :inverse_of => :parent
+      accepts_nested_attributes_for :child
+    end
+
+    class Child < ActiveRecord::Base
+      belongs_to :parent
+      validates_presence_of :parent
+    end
+
+Note that running the Child validations will now require loading the
+Parent if it's not already loaded.  On the upside, it will now also
+validate that the parent_id actually points to an existing record.
+However, you may wish to define a custom validation to check only the
+ID if the association is not set to avoid the extra database hit.
+
+Inverse Of supports `has_one`, `has_many`, and `belongs_to`
+associations, including polymorphic `belongs_to`.  Behavior should
+exactly match Rails 2.3.6; please file any differences
+[as a bug](http://github.com/oggy/inverse_of/issues).
+
+## Contributing
+
+* Bug reports: http://github.com/oggy/inverse_of/issues
+* Source: http://github.com/oggy/inverse_of
+* Patches: Fork on Github, send pull request.
+  * Ensure patch includes tests.
+  * Leave the version alone, or bump it in a separate commit.
+
+## Copyright
+
+Copyright (c) 2009-2010 George Ogata, released under the MIT license

data/Rakefile

@@ -0,0 +1,38 @@
+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

data/VERSION

@@ -0,0 +1 @@
+0.0.1

data/install.rb

@@ -0,0 +1 @@
+# Install hook code here

data/inverse_of.gemspec

@@ -0,0 +1,76 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{inverse_of}
+  s.version = "0.0.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["George Ogata"]
+  s.date = %q{2010-02-05}
+  s.description = %q{Backport of ActiveRecord 2.3.6's inverse associations.}
+  s.email = %q{george.ogata@gmail.com}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.markdown"
+  ]
+  s.files = [
+    ".document",
+     ".gitignore",
+     "LICENSE",
+     "MIT-LICENSE",
+     "README.markdown",
+     "Rakefile",
+     "VERSION",
+     "install.rb",
+     "inverse_of.gemspec",
+     "lib/inverse_of.rb",
+     "rails/init.rb",
+     "tasks/inverse_of_tasks.rake",
+     "test/cases/helper.rb",
+     "test/cases/inverse_associations_test.rb",
+     "test/fixtures/clubs.yml",
+     "test/fixtures/faces.yml",
+     "test/fixtures/interests.yml",
+     "test/fixtures/men.yml",
+     "test/fixtures/sponsors.yml",
+     "test/fixtures/zines.yml",
+     "test/models/club.rb",
+     "test/models/face.rb",
+     "test/models/interest.rb",
+     "test/models/man.rb",
+     "test/models/sponsor.rb",
+     "test/models/zine.rb",
+     "test/schema/schema.rb",
+     "uninstall.rb"
+  ]
+  s.homepage = %q{http://github.com/oggy/inverse_of}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.5}
+  s.summary = %q{Backport of ActiveRecord 2.3.6's inverse associations.}
+  s.test_files = [
+    "test/cases/helper.rb",
+     "test/cases/inverse_associations_test.rb",
+     "test/models/club.rb",
+     "test/models/face.rb",
+     "test/models/interest.rb",
+     "test/models/man.rb",
+     "test/models/sponsor.rb",
+     "test/models/zine.rb",
+     "test/schema/schema.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end
+

data/lib/inverse_of.rb

@@ -0,0 +1,293 @@
+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
+    end
+
+    module Reflection
+      def self.included(base)
+        base::AssociationReflection.send :include, AssociationReflection
+        base::ThroughReflection.send :include, ThroughReflection
+      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_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 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
+      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
+      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
+
+        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
+
+      module AssociationProxy
+        def self.included(base)
+          base.alias_method_chain :initialize, :inverse_of
+        end
+
+        def initialize_with_inverse_of(owner, reflection)
+          reflection.check_validity!
+          initialize_without_inverse_of(owner, reflection)
+        end
+
+        private
+
+        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
+
+        # Override in subclasses
+        def we_can_set_the_inverse_on_this?(record)
+          false
+        end
+      end
+
+      module BelongsToAssociation
+        def self.included(base)
+          base.alias_method_chain :replace, :inverse_of
+          base.alias_method_chain :find_target, :inverse_of
+        end
+
+        def replace_with_inverse_of(record)
+          replace_without_inverse_of(record)
+          set_inverse_instance(record, @owner)
+          record
+        end
+
+        def find_target_with_inverse_of
+          target = find_target_without_inverse_of and
+            set_inverse_instance(target, @owner)
+          target
+        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
+
+      module BelongsToPolymorphicAssociation
+        def self.included(base)
+          base.alias_method_chain :replace, :inverse_of
+          base.alias_method_chain :find_target, :inverse_of
+        end
+
+        def replace_with_inverse_of(record)
+          replace_without_inverse_of(record)
+          set_inverse_instance(record, @owner)
+          record
+        end
+
+        def find_target_with_inverse_of
+          target = find_target_without_inverse_of
+          set_inverse_instance(target, @owner)
+          target
+        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 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 HasManyAssociation
+        def we_can_set_the_inverse_on_this?(record)
+          inverse = @reflection.inverse_of
+          return !inverse.nil?
+        end
+      end
+
+      module HasManyThroughAssociation
+        def initialize(owner, reflection)
+          super
+        end
+
+        # NOTE - not sure that we can actually cope with inverses here
+        def we_can_set_the_inverse_on_this?(record)
+          false
+        end
+      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 find_target_with_inverse_of
+          target = find_target_without_inverse_of
+          set_inverse_instance(target, @owner)
+          target
+        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
+
+        private
+
+        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
+
+        def we_can_set_the_inverse_on_this?(record)
+          inverse = @reflection.inverse_of
+          return !inverse.nil?
+        end
+      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)
+          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 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
+          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
+end

data/rails/init.rb

@@ -0,0 +1 @@
+require 'inverse_of'

data/tasks/inverse_of_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :inverse_of do
+#   # Task goes here
+# end

data/test/cases/helper.rb

@@ -0,0 +1,28 @@
+require 'test/unit'
+require 'ruby-debug'
+require 'active_record'
+require 'active_record/test_case'
+require 'active_record/fixtures'
+
+ROOT = File.dirname(File.dirname(File.dirname(__FILE__)))
+
+require "#{ROOT}/rails/init"
+
+class ActiveSupport::TestCase
+  include ActiveRecord::TestFixtures
+
+  self.fixture_path = "#{ROOT}/test/fixtures"
+  self.use_instantiated_fixtures  = false
+  self.use_transactional_fixtures = true
+
+  def create_fixtures(*table_names, &block)
+    Fixtures.create_fixtures(ActiveSupport::TestCase.fixture_path, table_names, {}, &block)
+  end
+end
+
+ActiveRecord::Base.configurations = {'test' => {'adapter' => "sqlite3", 'database' => ":memory:"}}
+ActiveRecord::Base.establish_connection('test')
+ActiveRecord::Base.connection.instance_eval do
+  eval File.read("#{ROOT}/test/schema/schema.rb")
+end
+Dir["#{ROOT}/test/models/*.rb"].each{|path| require path}