polyamorous 1.1.0 → 1.2.0

data/lib/polyamorous/activerecord_4.2_ruby_2/join_association.rb

@@ -0,0 +1,37 @@
+# active_record_4.2_ruby_2/join_association.rb
+module Polyamorous
+  module JoinAssociationExtensions
+    include SwappingReflectionClass
+    def self.prepended(base)
+      base.class_eval { attr_reader :join_type }
+    end
+
+    def initialize(reflection, children, polymorphic_class = nil,
+      join_type = Arel::Nodes::InnerJoin)
+      @join_type = join_type
+      if polymorphic_class && ::ActiveRecord::Base > polymorphic_class
+        swapping_reflection_klass(reflection, polymorphic_class) do |reflection|
+          super(reflection, children)
+          self.reflection.options[:polymorphic] = true
+        end
+      else
+        super(reflection, children)
+      end
+    end
+
+    # Reference https://github.com/rails/rails/commit/9b15db51b78028bfecdb85595624de4b838adbd1
+    # NOTE Not sure we still need it?
+    def ==(other)
+      base_klass == other.base_klass
+    end
+
+    def build_constraint(klass, table, key, foreign_table, foreign_key)
+      if reflection.polymorphic?
+        super(klass, table, key, foreign_table, foreign_key)
+        .and(foreign_table[reflection.foreign_type].eq(reflection.klass.name))
+      else
+        super(klass, table, key, foreign_table, foreign_key)
+      end
+    end
+  end
+end

data/lib/polyamorous/{activerecord_4.1 → activerecord_4.2_ruby_2}/join_dependency.rb

@@ -1,41 +1,33 @@
+# active_record_4.2_ruby_2/join_dependency.rb
 module Polyamorous
   module JoinDependencyExtensions
-    def self.included(base)
-      base.extend ClassMethods
-
-      base.class_eval do
-        class << self
-          alias_method_chain :walk_tree, :polymorphism
-        end
-
-        alias_method_chain :build, :polymorphism
-        alias_method_chain :join_constraints, :polymorphism
-
-        if base.method_defined?(:active_record)
-          alias_method :base_klass, :active_record
-        end
-      end
-    end
-
-    def build_with_polymorphism(associations, base_klass)
+    # Replaces ActiveRecord::Associations::JoinDependency#build
+    def build(associations, base_klass)
       associations.map do |name, right|
         if name.is_a? Join
           reflection = find_reflection base_klass, name.name
           reflection.check_validity!
-
-          if reflection.options[:polymorphic]
-            JoinAssociation.new reflection, build(right, name.klass || base_klass), name.klass, name.type
+          if reflection.polymorphic?
+            JoinAssociation.new(
+              reflection,
+              build(right, name.klass || base_klass),
+              name.klass,
+              name.type
+            )
           else
-            JoinAssociation.new reflection, build(right, reflection.klass), name.klass, name.type
+            JoinAssociation.new(
+              reflection,
+              build(right, reflection.klass),
+              name.klass,
+              name.type
+            )
           end
         else
           reflection = find_reflection base_klass, name
           reflection.check_validity!
-
-          if reflection.options[:polymorphic]
+          if reflection.polymorphic?
             raise ActiveRecord::EagerLoadPolymorphicError.new(reflection)
           end
-
           JoinAssociation.new reflection, build(right, reflection.klass)
         end
       end
@@ -43,7 +35,7 @@ module Polyamorous
 
     def find_join_association_respecting_polymorphism(reflection, parent, klass)
       if association = parent.children.find { |j| j.reflection == reflection }
-        unless reflection.options[:polymorphic]
+        unless reflection.polymorphic?
           association
         else
           association if association.base_klass == klass
@@ -52,40 +44,44 @@ module Polyamorous
     end
 
     def build_join_association_respecting_polymorphism(reflection, parent, klass)
-      if reflection.options[:polymorphic] && klass
+      if reflection.polymorphic? && klass
         JoinAssociation.new(reflection, self, klass)
       else
         JoinAssociation.new(reflection, self)
       end
     end
 
-    def join_constraints_with_polymorphism(outer_joins)
+    # Replaces ActiveRecord::Associations::JoinDependency#join_constraints
+    # to call #make_joins instead of #make_inner_joins.
+    def join_constraints(outer_joins)
       joins = join_root.children.flat_map { |child|
-        make_joins join_root, child
+        make_joins(join_root, child)
       }
-
       joins.concat outer_joins.flat_map { |oj|
         if join_root.match? oj.join_root
-          walk join_root, oj.join_root
+          walk(join_root, oj.join_root)
         else
           oj.join_root.children.flat_map { |child|
-            make_outer_joins oj.join_root, child
+            make_outer_joins(oj.join_root, child)
           }
         end
       }
     end
 
+    # Replaces ActiveRecord::Associations::JoinDependency#make_inner_joins
     def make_joins(parent, child)
-      tables    = child.tables
-      joins     = make_constraints parent, child, tables, child.join_type || Arel::Nodes::InnerJoin
-
-      joins.concat child.children.flat_map { |c| make_joins(child, c) }
+      [
+        make_constraints(
+          parent, child, child.tables, child.join_type || Arel::Nodes::InnerJoin
+        )
+      ] + child.children.flat_map { |c| make_inner_joins(child, c) }
     end
 
     private :make_joins
 
     module ClassMethods
-      def walk_tree_with_polymorphism(associations, hash)
+    # Prepended before ActiveRecord::Associations::JoinDependency#self.walk_tree
+      def walk_tree(associations, hash)
         case associations
         when TreeNode
           associations.add_to_tree(hash)
@@ -93,16 +89,15 @@ module Polyamorous
           associations.each do |k, v|
             cache =
               case k
-                when TreeNode
-                  k.add_to_tree(hash)
-                else
-                  hash[k] ||= {}
-                end
-
+              when TreeNode
+                k.add_to_tree(hash)
+              else
+                hash[k] ||= {}
+              end
             walk_tree(v, cache)
           end
         else
-          walk_tree_without_polymorphism(associations, hash)
+          super(associations, hash)
         end
       end
     end

data/lib/polyamorous/swapping_reflection_class.rb

@@ -0,0 +1,11 @@
+module Polyamorous
+  module SwappingReflectionClass
+    def swapping_reflection_klass(reflection, klass)
+      new_reflection = reflection.clone
+      new_reflection.instance_variable_set(:@options, reflection.options.clone)
+      new_reflection.options.delete(:polymorphic)
+      new_reflection.instance_variable_set(:@klass, klass)
+      yield new_reflection
+    end
+  end
+end

data/lib/polyamorous/version.rb

@@ -1,3 +1,3 @@
 module Polyamorous
-  VERSION = "1.1.0"
+  VERSION = '1.2.0'
 end

data/polyamorous.gemspec

@@ -5,9 +5,10 @@ require "polyamorous/version"
 Gem::Specification.new do |s|
   s.name        = "polyamorous"
   s.version     = Polyamorous::VERSION
-  s.authors     = ["Ernie Miller"]
-  s.email       = ["ernie@metautonomo.us"]
-  s.homepage    = "http://github.com/ernie/polyamorous"
+  s.authors     = ["Ernie Miller", "Ryan Bigg", "Jon Atack", "Xiang Li"]
+  s.email       = ["ernie@erniemiller.org", "radarlistener@gmail.com", "jonnyatack@gmail.com", "bigxiang@gmail.com"]
+  s.homepage    = "https://github.com/activerecord-hackery/polyamorous"
+  s.license     = "MIT"
   s.summary     = %q{
     Loves/is loved by polymorphic belongs_to associations, Ransack, Squeel, MetaSearch...
   }

data/spec/polyamorous/join_association_spec.rb

@@ -2,10 +2,10 @@ require 'spec_helper'
 
 module Polyamorous
   describe JoinAssociation do
-    if ActiveRecord::VERSION::STRING >= "4.1"
-      include_examples "Join Association on ActiveRecord 4.1"
+    if ActiveRecord::VERSION::STRING >= '4.1'
+      include_examples 'Join Association on ActiveRecord 4.1'
     else
-      include_examples "Join Association on ActiveRecord 3 and 4.0"
+      include_examples 'Join Association on ActiveRecord 3 and 4.0'
     end
   end
 end

data/spec/polyamorous/join_dependency_spec.rb

@@ -2,10 +2,10 @@ require 'spec_helper'
 
 module Polyamorous
   describe JoinDependency do
-    if ActiveRecord::VERSION::STRING >= "4.1"
-      include_examples "Join Dependency on ActiveRecord 4.1"
+    if ActiveRecord::VERSION::STRING >= '4.1'
+      include_examples 'Join Dependency on ActiveRecord 4.1'
     else
-      include_examples "Join Dependency on ActiveRecord 3 and 4.0"
+      include_examples 'Join Dependency on ActiveRecord 3 and 4.0'
     end
   end
 end

data/spec/polyamorous/join_spec.rb

@@ -2,12 +2,12 @@ require 'spec_helper'
 
 module Polyamorous
   describe Join do
-    it "is a tree node" do
+    it 'is a tree node' do
       join = new_join(:articles, :outer)
       expect(join).to be_kind_of(TreeNode)
     end
 
-    it "can be add to a tree" do
+    it 'can be add to a tree' do
       join = new_join(:articles, :outer)
 
       tree_hash = {}

data/spec/spec_helper.rb

@@ -20,7 +20,15 @@ Sham.define do
 end
 
 RSpec.configure do |config|
-  config.before(:suite) { Schema.create }
+  config.before(:suite) do
+    message = "Running Polyamorous specs with #{
+      ActiveRecord::Base.connection.adapter_name
+      }, Active Record #{::ActiveRecord::VERSION::STRING}, Arel #{Arel::VERSION
+      } and Ruby #{RUBY_VERSION}"
+    line = '=' * message.length
+    puts line, message, line
+    Schema.create
+  end
   config.before(:all)   { Sham.reset(:before_all) }
   config.before(:each)  { Sham.reset(:before_each) }
 
@@ -32,4 +40,4 @@ RSpec::Matchers.define :be_like do |expected|
     actual.gsub(/^\s+|\s+$/, '').gsub(/\s+/, ' ').strip ==
       expected.gsub(/^\s+|\s+$/, '').gsub(/\s+/, ' ').strip
   end
-end
+end

data/spec/support/schema.rb

@@ -1,25 +1,22 @@
 require 'active_record'
 
-ActiveRecord::Base.establish_connection(
-  :adapter  => 'sqlite3',
-  :database => ':memory:'
-)
+ActiveRecord::Base.establish_connection(adapter: 'sqlite3', database: ':memory:')
 
 class Person < ActiveRecord::Base
-  belongs_to :parent, :class_name => 'Person', :foreign_key => :parent_id
-  has_many   :children, :class_name => 'Person', :foreign_key => :parent_id
+  belongs_to :parent, class_name: 'Person', foreign_key: :parent_id
+  has_many   :children, class_name: 'Person', foreign_key: :parent_id
   has_many   :articles
   has_many   :comments
-  has_many   :authored_article_comments, :through => :articles,
-             :foreign_key => :person_id, :source => :comments
-  has_many   :notes, :as => :notable
+  has_many   :authored_article_comments, through: :articles,
+             foreign_key: :person_id, source: :comments
+  has_many   :notes, as: :notable
 end
 
 class Article < ActiveRecord::Base
   belongs_to              :person
   has_many                :comments
   has_and_belongs_to_many :tags
-  has_many   :notes, :as => :notable
+  has_many   :notes, as:  :notable
 end
 
 class Comment < ActiveRecord::Base
@@ -32,71 +29,70 @@ class Tag < ActiveRecord::Base
 end
 
 class Note < ActiveRecord::Base
-  belongs_to :notable, :polymorphic => true
+  belongs_to :notable, polymorphic: true
 end
 
 module Schema
   def self.create
-    silence_stream(STDOUT) do
-
-      ActiveRecord::Schema.define do
-        create_table :people, :force => true do |t|
-          t.integer  :parent_id
-          t.string   :name
-          t.integer  :salary
-          t.boolean  :awesome, :default => false
-          t.timestamps
-        end
-
-        create_table :articles, :force => true do |t|
-          t.integer :person_id
-          t.string  :title
-          t.text    :body
-        end
+    ActiveRecord::Migration.verbose = false
+
+    ActiveRecord::Schema.define do
+      create_table :people, force: true do |t|
+        t.integer  :parent_id
+        t.string   :name
+        t.integer  :salary
+        t.boolean  :awesome, default: false
+        t.timestamps null: false
+      end
 
-        create_table :comments, :force => true do |t|
-          t.integer :article_id
-          t.integer :person_id
-          t.text    :body
-        end
+      create_table :articles, force: true do |t|
+        t.integer :person_id
+        t.string  :title
+        t.text    :body
+      end
 
-        create_table :tags, :force => true do |t|
-          t.string :name
-        end
+      create_table :comments, force: true do |t|
+        t.integer :article_id
+        t.integer :person_id
+        t.text    :body
+      end
 
-        create_table :articles_tags, :force => true, :id => false do |t|
-          t.integer :article_id
-          t.integer :tag_id
-        end
+      create_table :tags, force: true do |t|
+        t.string :name
+      end
 
-        create_table :notes, :force => true do |t|
-          t.integer :notable_id
-          t.string  :notable_type
-          t.string  :note
-        end
+      create_table :articles_tags, force: true, id: false do |t|
+        t.integer :article_id
+        t.integer :tag_id
+      end
 
+      create_table :notes, force: true do |t|
+        t.integer :notable_id
+        t.string  :notable_type
+        t.string  :note
       end
     end
 
     10.times do
       person = Person.make
-      Note.make(:notable => person)
+      Note.make(notable: person)
       3.times do
-        article = Article.make(:person => person)
+        article = Article.make(person: person)
         3.times do
           article.tags = [Tag.make, Tag.make, Tag.make]
         end
-        Note.make(:notable => article)
+        Note.make(notable: article)
         10.times do
-          Comment.make(:article => article)
+          Comment.make(article: article)
         end
       end
       2.times do
-        Comment.make(:person => person)
+        Comment.make(person: person)
       end
     end
 
-    Comment.make(:body => 'First post!', :article => Article.make(:title => 'Hello, world!'))
-
+    Comment.make(
+      body: 'First post!', article: Article.make(title: 'Hello, world!')
+    )
   end
 end

data/spec/support/shared_examples/join_association_3_and_4.0.rb

@@ -1,8 +1,10 @@
-shared_examples "Join Association on ActiveRecord 3 and 4.0" do
+shared_examples 'Join Association on ActiveRecord 3 and 4.0' do
   let(:join_dependency) { new_join_dependency Note, {} }
   let(:reflection) { Note.reflect_on_association(:notable) }
   let(:parent) { join_dependency.join_base }
-  let(:join_association) { new_join_association(reflection, join_dependency, parent, Article) }
+  let(:join_association) {
+    new_join_association(reflection, join_dependency, parent, Article)
+  }
 
   subject {
     join_dependency.build_join_association_respecting_polymorphism(
@@ -25,7 +27,8 @@ shared_examples "Join Association on ActiveRecord 3 and 4.0" do
 
   it 'leaves the orginal reflection intact for thread safety' do
     reflection.instance_variable_set(:@klass, Article)
-    join_association.swapping_reflection_klass(reflection, Person) do |new_reflection|
+    join_association
+    .swapping_reflection_klass(reflection, Person) do |new_reflection|
       expect(new_reflection.options).not_to equal reflection.options
       expect(new_reflection.options).not_to have_key(:polymorphic)
       expect(new_reflection.klass).to eq(Person)