nested_has_many_through 0.0.1

data/.gitignore

@@ -0,0 +1,4 @@
+.*
+!.gitignore
+pkg
+doc/*

data/Gemfile

@@ -0,0 +1,5 @@
+source "http://rubygems.org"
+
+gemspec
+
+# gem "rails"

data/Gemfile.lock

@@ -0,0 +1,94 @@
+PATH
+  remote: .
+  specs:
+    nested_has_many_through (0.0.1)
+      rails (>= 3.0.0)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    abstract (1.0.0)
+    actionmailer (3.0.6)
+      actionpack (= 3.0.6)
+      mail (~> 2.2.15)
+    actionpack (3.0.6)
+      activemodel (= 3.0.6)
+      activesupport (= 3.0.6)
+      builder (~> 2.1.2)
+      erubis (~> 2.6.6)
+      i18n (~> 0.5.0)
+      rack (~> 1.2.1)
+      rack-mount (~> 0.6.14)
+      rack-test (~> 0.5.7)
+      tzinfo (~> 0.3.23)
+    activemodel (3.0.6)
+      activesupport (= 3.0.6)
+      builder (~> 2.1.2)
+      i18n (~> 0.5.0)
+    activerecord (3.0.6)
+      activemodel (= 3.0.6)
+      activesupport (= 3.0.6)
+      arel (~> 2.0.2)
+      tzinfo (~> 0.3.23)
+    activeresource (3.0.6)
+      activemodel (= 3.0.6)
+      activesupport (= 3.0.6)
+    activesupport (3.0.6)
+    arel (2.0.9)
+    builder (2.1.2)
+    diff-lcs (1.1.2)
+    erubis (2.6.6)
+      abstract (>= 1.0.0)
+    i18n (0.5.0)
+    mail (2.2.15)
+      activesupport (>= 2.3.6)
+      i18n (>= 0.4.0)
+      mime-types (~> 1.16)
+      treetop (~> 1.4.8)
+    mime-types (1.16)
+    polyglot (0.3.1)
+    rack (1.2.2)
+    rack-mount (0.6.14)
+      rack (>= 1.0.0)
+    rack-test (0.5.7)
+      rack (>= 1.0)
+    rails (3.0.6)
+      actionmailer (= 3.0.6)
+      actionpack (= 3.0.6)
+      activerecord (= 3.0.6)
+      activeresource (= 3.0.6)
+      activesupport (= 3.0.6)
+      bundler (~> 1.0)
+      railties (= 3.0.6)
+    railties (3.0.6)
+      actionpack (= 3.0.6)
+      activesupport (= 3.0.6)
+      rake (>= 0.8.7)
+      thor (~> 0.14.4)
+    rake (0.8.7)
+    rspec (2.5.0)
+      rspec-core (~> 2.5.0)
+      rspec-expectations (~> 2.5.0)
+      rspec-mocks (~> 2.5.0)
+    rspec-core (2.5.1)
+    rspec-expectations (2.5.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.5.0)
+    sqlite3 (1.3.3)
+    sqlite3-ruby (1.3.3)
+      sqlite3 (>= 1.3.3)
+    thor (0.14.6)
+    treetop (1.4.9)
+      polyglot (>= 0.3.1)
+    tzinfo (0.3.26)
+    yard (0.6.7)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (>= 1.0.0)
+  nested_has_many_through!
+  rspec (~> 2.5.0)
+  sqlite3-ruby
+  yard

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2008 Ian White - ian.w.white@gmail.com
+
+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.rdoc

@@ -0,0 +1,61 @@
+= NestedHasManyThrough
+
+This gem makes it possible to define has_many :through relationships that
+go through other has_many :through relationships, possibly through an
+arbitrarily deep hierarchy. This allows associations across any number of
+tables to be constructed, without having to resort to find_by_sql (which isn't
+a suitable solution if you need to do eager loading through :include as well).
+
+NOTE: Rails 3.x supports only. Rails 2.3 users might want to try the original nested_has_many_through[https://github.com/ianwhite/nested_has_many_through] plugin
+
+== Intallation
+
+Install the gem:
+
+    gem install nested_has_many_through
+
+Add it to your gem file::
+
+    gem "nested_has_many_through"
+
+== Usage
+
+    class Author < User
+      has_many :posts
+      has_many :categories, :through => :posts, :uniq => true
+      has_many :similar_posts, :through => :categories, :source => :posts
+      has_many :similar_authors, :through => :similar_posts, :source => :author, :uniq => true
+      has_many :posts_of_similar_authors, :through => :similar_authors, :source => :posts, :uniq => true
+      has_many :commenters, :through => :posts, :uniq => true
+    end
+
+    class Post < ActiveRecord::Base
+      belongs_to :author
+      belongs_to :category
+      has_many :comments
+      has_many :commenters, :through => :comments, :source => :user, :uniq => true
+    end
+
+The first two has_manys of Author are plain vanilla, the last four are what this plugin enables
+
+    # has_many through a has_many :through
+    has_many :similar_posts, :through => :categories, :source => :posts
+
+    # doubly nested has_many :through
+    has_many :similar_authors, :through => :similar_posts, :source => :author, :uniq => true
+
+    # whoah!
+    has_many :posts_of_similar_authors, :through => :similar_authors, :source => :posts, :uniq => true
+
+    # has_many through a has_many :through in another model
+    has_many :commenters, :through => :posts, :uniq => true
+
+== Maintainers
+
+* Roman V. Babenko (http://github.com/romanvbabenko)
+
+== Copyrights
+
+This gem based on code nested_has_many_through[https://github.com/ianwhite/nested_has_many_through] plugin
+
+MIT License. Copyright (c) 2008 Ian White - ian.w.white@gmail.com

data/Rakefile

@@ -0,0 +1,12 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+desc 'Default: run tests for nested_has_many_through'
+task :default => :spec
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec)
+task :default => :spec
+

data/init.rb

@@ -0,0 +1,2 @@
+require 'nested_has_many_through'
+

data/lib/nested_has_many_through/association.rb

@@ -0,0 +1,132 @@
+module NestedHasManyThrough
+  module Association
+    def self.included(base)
+      base.class_eval do
+        def construct_conditions
+          @nested_join_attributes ||= construct_nested_join_attributes
+          if @reflection.through_reflection && @reflection.through_reflection.macro == :belongs_to
+            "#{@nested_join_attributes[:remote_key]} = #{belongs_to_quoted_key} #{@nested_join_attributes[:conditions]}"
+          else
+            "#{@nested_join_attributes[:remote_key]} = #{@owner.quoted_id} #{@nested_join_attributes[:conditions]}"
+          end
+          "#{@nested_join_attributes[:remote_key]} = #{@owner.quoted_id} #{@nested_join_attributes[:conditions]}"
+        end
+
+        def construct_joins(custom_joins = nil)
+          @nested_join_attributes ||= construct_nested_join_attributes
+          "#{@nested_join_attributes[:joins]} #{custom_joins}"
+        end
+      end
+    end
+
+  protected
+    # Given any belongs_to or has_many (including has_many :through) association,
+    # return the essential components of a join corresponding to that association, namely:
+    #
+    # * <tt>:joins</tt>: any additional joins required to get from the association's table
+    #   (reflection.table_name) to the table that's actually joining to the active record's table
+    # * <tt>:remote_key</tt>: the name of the key in the join table (qualified by table name) which will join
+    #   to a field of the active record's table
+    # * <tt>:local_key</tt>: the name of the key in the local table (not qualified by table name) which will
+    #   take part in the join
+    # * <tt>:conditions</tt>: any additional conditions (e.g. filtering by type for a polymorphic association,
+    #    or a :conditions clause explicitly given in the association), including a leading AND
+    def construct_nested_join_attributes(reflection = @reflection, association_class = reflection.klass,
+                                          table_ids = {association_class.table_name => 1})
+      if reflection.macro == :has_many && reflection.through_reflection
+        construct_has_many_through_attributes(reflection, table_ids)
+      else
+        construct_has_many_or_belongs_to_attributes(reflection, association_class, table_ids)
+      end
+    end
+
+    def construct_has_many_through_attributes(reflection, table_ids)
+      # Construct the join components of the source association, so that we have a path from
+      # the eventual target table of the association up to the table named in :through, and
+      # all tables involved are allocated table IDs.
+      source_attrs = construct_nested_join_attributes(reflection.source_reflection, reflection.klass, table_ids)
+
+      # Determine the alias of the :through table; this will be the last table assigned
+      # when constructing the source join components above.
+      through_table_alias = through_table_name = reflection.through_reflection.table_name
+      through_table_alias += "_#{table_ids[through_table_name]}" unless table_ids[through_table_name] == 1
+
+      # Construct the join components of the through association, so that we have a path to
+      # the active record's table.
+      through_attrs = construct_nested_join_attributes(reflection.through_reflection, reflection.through_reflection.klass, table_ids)
+
+      # Any subsequent joins / filters on owner attributes will act on the through association,
+      # so that's what we return for the conditions/keys of the overall association.
+      conditions = through_attrs[:conditions]
+      conditions += " AND #{interpolate_sql(reflection.klass.send(:sanitize_sql, reflection.options[:conditions]))}" if reflection.options[:conditions]
+
+      {
+        :joins => "%s INNER JOIN %s ON ( %s = %s.%s %s) %s %s" % [
+          source_attrs[:joins],
+          through_table_name == through_table_alias ? through_table_name : "#{through_table_name} #{through_table_alias}",
+          source_attrs[:remote_key],
+          through_table_alias, source_attrs[:local_key],
+          source_attrs[:conditions],
+          through_attrs[:joins],
+          reflection.options[:joins]
+        ],
+        :remote_key => through_attrs[:remote_key],
+        :local_key => through_attrs[:local_key],
+        :conditions => conditions
+      }
+    end
+
+    # reflection is not has_many :through; it's a standard has_many / belongs_to instead
+    # TODO: see if we can defer to rails code here a bit more
+    def construct_has_many_or_belongs_to_attributes(reflection, association_class, table_ids)
+      # Determine the alias used for remote_table_name, if any. In all cases this will already
+      # have been assigned an ID in table_ids (either through being involved in a previous join,
+      # or - if it's the first table in the query - as the default value of table_ids)
+      remote_table_alias = remote_table_name = association_class.table_name
+      remote_table_alias += "_#{table_ids[remote_table_name]}" unless table_ids[remote_table_name] == 1
+
+      # Assign a new alias for the local table.
+      local_table_alias = local_table_name = reflection.active_record.table_name
+      if table_ids[local_table_name]
+        table_id = table_ids[local_table_name] += 1
+        local_table_alias += "_#{table_id}"
+      else
+        table_ids[local_table_name] = 1
+      end
+
+      conditions = ''
+      # Add type_condition, if applicable
+      conditions += " AND #{association_class.send(:type_condition).to_sql}" if association_class.finder_needs_type_condition?
+      # Add custom conditions
+      conditions += " AND (#{interpolate_sql(association_class.send(:sanitize_sql, reflection.options[:conditions]))})" if reflection.options[:conditions]
+
+      if reflection.macro == :belongs_to
+        if reflection.options[:polymorphic]
+          conditions += " AND #{local_table_alias}.#{reflection.options[:foreign_type]} = #{reflection.active_record.quote_value(association_class.base_class.name.to_s)}"
+        end
+        {
+          :joins => reflection.options[:joins],
+          :remote_key => "#{remote_table_alias}.#{association_class.primary_key}",
+          :local_key => reflection.primary_key_name,
+          :conditions => conditions
+        }
+      else
+        # Association is has_many (without :through)
+        if reflection.options[:as]
+          conditions += " AND #{remote_table_alias}.#{reflection.options[:as]}_type = #{reflection.active_record.quote_value(reflection.active_record.base_class.name.to_s)}"
+        end
+        {
+          :joins => "#{reflection.options[:joins]}",
+          :remote_key => "#{remote_table_alias}.#{reflection.primary_key_name}",
+          :local_key => reflection.klass.primary_key,
+          :conditions => conditions
+        }
+      end
+    end
+  end
+
+  def belongs_to_quoted_key
+    attribute, col = @reflection.through_reflection.primary_key_name, @owner.column_for_attribute(attribute)
+    @owner.send(:quote_value, @owner.send(attribute), col)
+  end
+end

data/lib/nested_has_many_through/reflection.rb

@@ -0,0 +1,14 @@
+module NestedHasManyThrough
+  module Reflection # :nodoc:
+    def self.included(base)
+      base.send :alias_method_chain, :check_validity!, :nested_has_many_through
+    end
+
+    def check_validity_with_nested_has_many_through!
+      check_validity_without_nested_has_many_through!
+    rescue ActiveRecord::HasManyThroughSourceAssociationMacroError => e
+      # now we permit has many through to a :though source
+      raise e unless source_reflection.options[:through]
+    end
+  end
+end

data/lib/nested_has_many_through/version.rb

@@ -0,0 +1,3 @@
+module NestedHasManyThrough
+  VERSION = "0.0.1"
+end

data/lib/nested_has_many_through.rb

@@ -0,0 +1,15 @@
+require "nested_has_many_through/association"
+require "nested_has_many_through/reflection"
+
+module NestedHasManyThrough
+  autoload :Association, 'nested_has_many_through/association'
+  autoload :Reflection, 'nested_has_many_through/reflection'
+end
+
+ActiveRecord::Associations::HasManyThroughAssociation.send :include, NestedHasManyThrough::Association
+
+if defined?(ActiveRecord::Reflection::ThroughReflection)
+  ActiveRecord::Reflection::ThroughReflection.send :include, NestedHasManyThrough::Reflection
+else
+  ActiveRecord::Reflection::AssociationReflection.send :include, NestedHasManyThrough::Reflection
+end

data/nested_has_many_through.gemspec

@@ -0,0 +1,32 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "nested_has_many_through/version"
+
+Gem::Specification.new do |s|
+  s.name        = "nested_has_many_through"
+  s.version     = NestedHasManyThrough::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Ian White"]
+  s.email       = ["ian.w.white@gmail.com"]
+  s.homepage    = "http://twitter.com/i2w"
+  s.summary     = %q{Rails gem that allows has_many :through to go through other has_many :throughs}
+  s.description = %q{This plugin makes it possible to define has_many :through relationships that
+  go through other has_many :through relationships, possibly through an arbitrarily deep hierarchy.
+  This allows associations across any number of tables to be constructed, without having to resort to
+  find_by_sql (which isn't a suitable solution if you need to do eager loading through :include as well).}
+
+  s.rubyforge_project = "nested_has_many_through"
+
+  s.add_dependency "rails", ">= 3.0.0"
+
+  s.add_development_dependency "bundler", ">= 1.0.0"
+  s.add_development_dependency "rspec", "~> 2.5.0"
+  s.add_development_dependency "yard"
+  s.add_development_dependency "sqlite3-ruby"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end
+

data/spec/models/author_spec.rb

@@ -0,0 +1,84 @@
+require "spec_helper"
+
+describe Author do
+  describe "(newly created)" do
+    before do
+      @category = Category.create!
+      @other_category = Category.create!
+      @author = Author.create!
+    end
+
+    it "#posts should == []" do
+      @author.posts.should == []
+    end
+
+    it "#categories should == []" do
+      @author.categories.should == []
+    end
+
+    it "#similar_posts should == []" do
+      @author.similar_posts.should be_empty
+    end
+
+    it "#similar_authors should == []" do
+      @author.similar_authors.should be_empty
+    end
+
+    it "#commenters should == []" do
+      @author.commenters.should == []
+    end
+
+    describe "who creates post with category" do
+      before do
+        @post = Post.create! :author => @author, :category => @category
+      end
+
+      it "#posts should == [post]" do
+        @author.posts.should == [@post]
+      end
+
+      it "#categories should == [category]" do
+        @author.categories.should == [@category]
+      end
+
+      describe "and @other_author creates post2 in category" do
+
+        before do
+          @other_author = Author.create!
+          @post2 = Post.create! :author => @other_author, :category => @category
+        end
+
+        it "#posts should == [post2]" do
+          @author.posts.should == [@post]
+        end
+
+        it "#categories should == [category]" do
+          @author.categories.should == [@category]
+        end
+
+        it "#similar_posts.should == [post, post2]" do
+          @author.similar_posts.should == [@post, @post2]
+        end
+
+        it "#similar_authors.should == [@author, @other_author]" do
+          @author.similar_authors.should == [@author, @other_author]
+        end
+
+        describe "and creates @other_post in @other_category" do
+          before do
+            @other_category = Category.create!
+            @other_post = Post.create! :author => @other_author, :category => @other_category
+          end
+
+          it "#similar_posts.should == [@post, @post2]" do
+            @author.similar_posts.should == [@post, @post2]
+          end
+
+          it "#posts_by_similar_authors.should == [@post, @post2, @other_post]" do
+            @author.posts_of_similar_authors.should == [@post, @post2, @other_post]
+          end
+        end
+      end
+    end
+  end
+end

data/spec/models/commenter_spec.rb

@@ -0,0 +1,108 @@
+require "spec_helper"
+
+describe 'Commenter use case (a1: p1>c1, a2: p2>c1, p3>c2, a3: p4>c3)' do
+  before do
+    @c1 = Category.create!
+    @c2 = Category.create!
+    @c3 = Category.create!
+    @a1 = Author.create!
+    @a2 = Author.create!
+    @a3 = Author.create!
+    @p1 = @a1.posts.create! :category => @c1
+    @p2 = @a2.posts.create! :category => @c1
+    @p3 = @a2.posts.create! :category => @c2
+    @p4 = @a3.posts.create! :category => @c3
+    @a1.reload
+    @a2.reload
+  end
+
+  it "a1.posts should == [p1]" do
+    @a1.posts.should == [@p1]
+  end
+
+  it "a1.categories should == [c1]" do
+    @a1.categories.should == [@c1]
+  end
+
+  it "a2.posts should == [p2, p3]" do
+    @a2.posts.should == [@p2, @p3]
+  end
+
+  it "a2.categories should == [c1, c2]" do
+    @a2.categories.should == [@c1, @c2]
+  end
+
+  describe "u1 comments on p2" do
+    before do
+      @u1 = User.create!
+      @comment = @p2.comments.create! :user => @u1
+    end
+
+    it "u1.comments should == [comment]" do
+      @u1.comments.should == [@comment]
+    end
+
+    it "a1.commenters should be empty" do
+      @a1.commenters.should be_empty
+    end
+
+    it "a2.commenters should == [u1]" do
+      @a2.commenters.should == [@u1]
+    end
+
+    it "u1.commented_posts should == [p2]" do
+      @u1.commented_posts.should == [@p2]
+    end
+
+    it "u1.commented_posts.find_inflamatory(:all) should be empty" do
+      @u1.commented_posts.find_inflamatory(:all).should be_empty
+    end
+
+    if ActiveRecord::Base.respond_to?(:named_scope)
+      it "u1.commented_posts.inflamatory should be empty" do
+        @u1.commented_posts.inflamatory.should be_empty
+      end
+    end
+
+    it "u1.commented_authors should == [a2]" do
+      @u1.commented_authors.should == [@a2]
+    end
+
+    it "u1.posts_of_interest should == [p1, p2, p3]" do
+      @u1.posts_of_interest.should == [@p1, @p2, @p3]
+    end
+
+    it "u1.categories_of_interest should == [c1, c2]" do
+      @u1.categories_of_interest.should == [@c1, @c2]
+    end
+
+    describe "when p2 is inflamatory" do
+      before do
+        @p2.toggle!(:inflamatory)
+      end
+
+      it "p2 should be inflamatory" do
+        @p2.should be_inflamatory
+      end
+
+      it "u1.commented_posts.find_inflamatory(:all) should == [p2]" do
+        # uniq ids is here (and next spec) because eager loading changed behaviour 2.0.2 => edge
+        @u1.commented_posts.find_inflamatory(:all).collect(&:id).uniq.should == [@p2.id]
+      end
+
+      it "u1.posts_of_interest.find_inflamatory(:all).uniq should == [p2]" do
+        @u1.posts_of_interest.find_inflamatory(:all).collect(&:id).uniq.should == [@p2.id]
+      end
+
+      if ActiveRecord::Base.respond_to?(:named_scope)
+        it "u1.commented_posts.inflamatory should == [p2]" do
+          @u1.commented_posts.inflamatory.should == [@p2]
+        end
+
+        it "u1.posts_of_interest.inflamatory should == [p2]" do
+          @u1.posts_of_interest.inflamatory.should == [@p2]
+        end
+      end
+    end
+  end
+end

data/spec/rails_app/.gitignore

@@ -0,0 +1,4 @@
+.bundle
+db/*.sqlite3
+log/*.log
+tmp/

data/spec/rails_app/Gemfile

@@ -0,0 +1,31 @@
+source 'http://rubygems.org'
+
+gem 'rails', '3.0.0'
+
+# Bundle edge Rails instead:
+# gem 'rails', :git => 'git://github.com/rails/rails.git'
+
+gem 'sqlite3'
+
+# Use unicorn as the web server
+# gem 'unicorn'
+
+# Deploy with Capistrano
+# gem 'capistrano'
+
+# To use debugger (ruby-debug for Ruby 1.8.7+, ruby-debug19 for Ruby 1.9.2+)
+# gem 'ruby-debug'
+# gem 'ruby-debug19', :require => 'ruby-debug'
+
+# Bundle the extra gems:
+# gem 'bj'
+# gem 'nokogiri'
+# gem 'sqlite3-ruby', :require => 'sqlite3'
+# gem 'aws-s3', :require => 'aws/s3'
+
+# Bundle gems for the local environment. Make sure to
+# put test-only gems in this group so their generators
+# and rake tasks are available in development mode:
+# group :development, :test do
+#   gem 'webrat'
+# end