includes_many 0.1.0

data/lib/includes_many/active_record32/join_association.rb

@@ -0,0 +1,37 @@
+module ActiveRecord
+  class NonScalarPrimaryKeyError < ::ActiveRecord::ActiveRecordError
+    def initialize(reflection)
+      super("Can not join association #{reflection.name.inspect}, because :primary_key is a callable. Use Relation#includes or specify a join column name")
+    end
+  end
+
+  module Associations
+    class JoinDependency
+      class JoinAssociation
+        def initialize(reflection, join_dependency, parent = nil)
+          reflection.check_validity!
+
+          # PATCH here
+          if reflection.options[:primary_key].respond_to?(:call)
+            raise NonScalarPrimaryKeyError.new(reflection)
+          end
+          # end PATCH
+
+          if reflection.options[:polymorphic]
+            raise EagerLoadPolymorphicError.new(reflection)
+          end
+
+          super(reflection.klass)
+
+          @reflection      = reflection
+          @join_dependency = join_dependency
+          @parent          = parent
+          @join_type       = Arel::InnerJoin
+          @aliased_prefix  = "t#{ join_dependency.join_parts.size }"
+          @tables          = construct_tables.reverse
+        end
+      end
+    end
+  end
+end
+

data/lib/includes_many/active_record40.rb

@@ -0,0 +1,4 @@
+require 'includes_many/active_record40/association_scope'
+require 'includes_many/active_record40/has_many'
+require 'includes_many/active_record40/join_association'
+

data/lib/includes_many/active_record40/association_scope.rb

@@ -0,0 +1,97 @@
+module ActiveRecord
+  module Associations
+    class AssociationScope
+      safe_monkeypatch :add_constraints, md5: 'fa15ef6f1cd4fb164746dc2bb3dcb887'
+
+      def add_constraints(scope)
+        tables = construct_tables
+
+        chain.each_with_index do |reflection, i|
+          table, foreign_table = tables.shift, tables.first
+
+          if reflection.source_macro == :has_and_belongs_to_many
+            join_table = tables.shift
+
+            scope = scope.joins(join(
+              join_table,
+              table[reflection.association_primary_key].
+                eq(join_table[reflection.association_foreign_key])
+            ))
+
+            table, foreign_table = join_table, tables.first
+          end
+
+          if reflection.source_macro == :belongs_to
+            if reflection.options[:polymorphic]
+              key = reflection.association_primary_key(self.klass)
+            else
+              key = reflection.association_primary_key
+            end
+
+            foreign_key = reflection.foreign_key
+          else
+            key         = reflection.foreign_key
+            foreign_key = reflection.active_record_primary_key
+          end
+
+          if reflection == chain.last
+            bind_arel = if foreign_key.respond_to?(:call)
+              fk = foreign_key.call(owner)
+              if fk.respond_to?(:each)
+                bind_vals = fk.compact.map do |f|
+                  bind scope, table.table_name, key.to_s, f
+                end
+                table[key].in(bind_vals)
+              else
+                bind_val = bind scope, table.table_name, key.to_s, fk
+                table[key].eq(bind_val)
+              end
+            else
+              bind_val = bind scope, table.table_name, reflection.type.to_s, value
+              table[reflection.type].eq(bind_val)
+            end
+            scope    = scope.where(bind_arel)
+
+            if reflection.type
+              value    = owner.class.base_class.name
+              bind_val = bind scope, table.table_name, reflection.type.to_s, value
+              scope    = scope.where(table[reflection.type].eq(bind_val))
+            end
+          else
+            constraint = table[key].eq(foreign_table[foreign_key])
+
+            if reflection.type
+              type = chain[i + 1].klass.base_class.name
+              constraint = constraint.and(table[reflection.type].eq(type))
+            end
+
+            scope = scope.joins(join(foreign_table, constraint))
+          end
+
+          is_first_chain = i == 0
+          klass = is_first_chain ? self.klass : reflection.klass
+
+          # Exclude the scope of the association itself, because that
+          # was already merged in the #scope method.
+          scope_chain[i].each do |scope_chain_item|
+            item  = eval_scope(klass, scope_chain_item)
+
+            if scope_chain_item == self.reflection.scope
+              scope.merge! item.except(:where, :includes)
+            end
+
+            if is_first_chain
+              scope.includes! item.includes_values
+            end
+
+            scope.where_values += item.where_values
+            scope.order_values |= item.order_values
+          end
+        end
+
+        scope
+      end
+    end
+  end
+end
+

data/lib/includes_many/active_record40/has_many.rb

@@ -0,0 +1,32 @@
+module ActiveRecord
+  module Associations
+    class Preloader
+      class HasMany
+        safe_monkeypatch :owners_by_key, md5: '33eab3037fd994d4a7106a68a05f169d'
+
+        def owners_by_key
+          @owners_by_key ||= begin
+            res = Hash.new { |h,k| h[k] = Set.new }
+            owners.each do |owner|
+              key = if owner_key_name.respond_to?(:call)
+                owner_key_name.call(owner)
+              else
+                owner[owner_key_name]
+              end
+
+              if key.respond_to?(:each)
+                key.each do |k|
+                  res[k && k.to_s] << owner
+                end
+              else
+                res[key && key.to_s] << owner
+              end
+            end
+            res
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/includes_many/active_record40/join_association.rb

@@ -0,0 +1,35 @@
+module ActiveRecord
+  class NonScalarPrimaryKeyError < ActiveRecordError
+    def initialize(reflection)
+      super("Can not join association #{reflection.name.inspect}, because :primary_key is a callable. Use Relation#includes or specify a join column name")
+    end
+  end
+
+  module Associations
+    class JoinDependency
+      class JoinAssociation
+        safe_monkeypatch :initialize, md5: 'b1b62d42c897ef2e2c4db921a97bad5b'
+
+        def initialize(reflection, join_dependency, parent = nil)
+          reflection.check_validity!
+
+          # PATCH here
+          if reflection.options[:primary_key].respond_to?(:call)
+            raise NonScalarPrimaryKeyError.new(reflection)
+          end
+          # end PATCH
+
+          super(reflection.klass)
+
+          @reflection      = reflection
+          @join_dependency = join_dependency
+          @parent          = parent
+          @join_type       = Arel::InnerJoin
+          @aliased_prefix  = "t#{ join_dependency.join_parts.size }"
+          @tables          = construct_tables.reverse
+        end
+      end
+    end
+  end
+end
+

data/lib/includes_many/active_record41.rb

@@ -0,0 +1,4 @@
+require 'includes_many/active_record41/association_scope'
+require 'includes_many/active_record41/has_many'
+require 'includes_many/active_record41/join_association'
+

data/lib/includes_many/active_record41/association_scope.rb

@@ -0,0 +1,88 @@
+module ActiveRecord
+  module Associations
+    class AssociationScope
+      safe_monkeypatch :add_constraints, md5: '0bfea41607ffb2444b96cb429663fb63'
+
+      def add_constraints(scope, owner, assoc_klass, refl, tracker)
+        chain = refl.chain
+        scope_chain = refl.scope_chain
+
+        tables = construct_tables(chain, assoc_klass, refl, tracker)
+
+        chain.each_with_index do |reflection, i|
+          table, foreign_table = tables.shift, tables.first
+
+          if reflection.source_macro == :belongs_to
+            if reflection.options[:polymorphic]
+              key = reflection.association_primary_key(assoc_klass)
+            else
+              key = reflection.association_primary_key
+            end
+
+            foreign_key = reflection.foreign_key
+          else
+            key         = reflection.foreign_key
+            foreign_key = reflection.active_record_primary_key
+          end
+
+          if reflection == chain.last
+            bind_arel = if foreign_key.respond_to?(:call)
+              fk = foreign_key.call(owner)
+              if fk.respond_to?(:each)
+                bind_vals = fk.compact.map do |f|
+                  bind scope, table.table_name, key.to_s, f, tracker
+                end
+                table[key].in(bind_vals)
+              else
+                table[key].eq(fk)
+              end
+            else
+              bind_val = bind scope, table.table_name, key.to_s, owner[foreign_key], tracker
+              table[key].eq(bind_val)
+            end
+            scope = scope.where(bind_arel)
+
+            if reflection.type
+              value    = owner.class.base_class.name
+              bind_val = bind scope, table.table_name, reflection.type.to_s, value, tracker
+              scope    = scope.where(table[reflection.type].eq(bind_val))
+            end
+          else
+            constraint = table[key].eq(foreign_table[foreign_key])
+
+            if reflection.type
+              value    = chain[i + 1].klass.base_class.name
+              bind_val = bind scope, table.table_name, reflection.type.to_s, value, tracker
+              scope    = scope.where(table[reflection.type].eq(bind_val))
+            end
+
+            scope = scope.joins(join(foreign_table, constraint))
+          end
+
+          is_first_chain = i == 0
+          klass = is_first_chain ? assoc_klass : reflection.klass
+
+          # Exclude the scope of the association itself, because that
+          # was already merged in the #scope method.
+          scope_chain[i].each do |scope_chain_item|
+            item  = eval_scope(klass, scope_chain_item, owner)
+
+            if scope_chain_item == refl.scope
+              scope.merge! item.except(:where, :includes, :bind)
+            end
+
+            if is_first_chain
+              scope.includes! item.includes_values
+            end
+
+            scope.where_values += item.where_values
+            scope.order_values |= item.order_values
+          end
+        end
+
+        scope
+      end
+    end
+  end
+end
+

data/lib/includes_many/active_record41/has_many.rb

@@ -0,0 +1,34 @@
+module ActiveRecord
+  module Associations
+    class Preloader
+      class HasMany
+        safe_monkeypatch :owners_by_key, md5: '70b0628dd3c79928ee0bcff75052894a'
+
+        def owners_by_key
+          @owners_by_key ||= begin
+            res = Hash.new { |h,k| h[k] = Set.new }
+            owners.each do |owner|
+              key = if owner_key_name.respond_to?(:call)
+                owner_key_name.call(owner)
+              else
+                owner[owner_key_name]
+              end
+
+              if key.respond_to?(:each)
+                key.each do |k|
+                  k = k.to_s if key_conversion_required?
+                  res[k] << owner
+                end
+              else
+                key = key.to_s if key_conversion_required?
+                res[key] << owner
+              end
+            end
+            res
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/includes_many/active_record41/join_association.rb

@@ -0,0 +1,30 @@
+module ActiveRecord
+  class NonScalarPrimaryKeyError < ActiveRecordError
+    def initialize(reflection)
+      super("Can not join association #{reflection.name.inspect}, because :primary_key is a callable. Use Relation#includes or specify a join column name")
+    end
+  end
+
+  module Associations
+    class JoinDependency
+      class JoinAssociation
+        safe_monkeypatch :initialize, md5: '2332c88140aa9e9efa96975fd48e6958'
+
+        def initialize(reflection, children)
+
+          # PATCH here
+          if reflection.options[:primary_key].respond_to?(:call)
+            raise NonScalarPrimaryKeyError.new(reflection)
+          end
+          # end PATCH
+
+          super(reflection.klass, children)
+
+          @reflection      = reflection
+          @tables          = nil
+        end
+      end
+    end
+  end
+end
+

data/lib/includes_many/active_record42.rb

@@ -0,0 +1,4 @@
+require 'includes_many/active_record42/association_scope'
+require 'includes_many/active_record42/has_many'
+require 'includes_many/active_record42/join_association'
+

data/lib/includes_many/active_record42/association_scope.rb

@@ -0,0 +1,81 @@
+module ActiveRecord
+  module Associations
+    class AssociationScope
+      safe_monkeypatch :add_constraints, md5: '191225b52dbc5ff8fd658b76a9b9b840', error: 'fails on Fri Aug 8 16:10:06 2014 +0200 f4c8ce9'
+
+      def add_constraints(scope, owner, assoc_klass, refl, tracker)
+        chain = refl.chain
+        scope_chain = refl.scope_chain
+
+        tables = construct_tables(chain, assoc_klass, refl, tracker)
+
+        chain.each_with_index do |reflection, i|
+          table, foreign_table = tables.shift, tables.first
+
+          join_keys = reflection.join_keys(assoc_klass)
+          key = join_keys.key
+          foreign_key = join_keys.foreign_key
+
+          if reflection == chain.last
+            bind_arel = if foreign_key.respond_to?(:call)
+              fk = foreign_key.call(owner)
+              if fk.respond_to?(:each)
+                bind_vals = fk.compact.map do |f|
+                  bind scope, table.table_name, key.to_s, f, tracker
+                end
+                table[key].in(bind_vals)
+              else
+                bind_val = bind scope, table.table_name, key.to_s, fk, tracker
+                table[key].eq(bind_val)
+              end
+            else
+              bind_val = bind scope, table.table_name, key.to_s, owner[foreign_key], tracker
+              table[key].eq(bind_val)
+            end
+            scope = scope.where(bind_arel)
+
+            if reflection.type
+              value    = owner.class.base_class.name
+              bind_val = bind scope, table.table_name, reflection.type.to_s, value, tracker
+              scope    = scope.where(table[reflection.type].eq(bind_val))
+            end
+          else
+            constraint = table[key].eq(foreign_table[foreign_key])
+
+            if reflection.type
+              value    = chain[i + 1].klass.base_class.name
+              bind_val = bind scope, table.table_name, reflection.type.to_s, value, tracker
+              scope    = scope.where(table[reflection.type].eq(bind_val))
+            end
+
+            scope = scope.joins(join(foreign_table, constraint))
+          end
+
+          is_first_chain = i == 0
+          klass = is_first_chain ? assoc_klass : reflection.klass
+
+          # Exclude the scope of the association itself, because that
+          # was already merged in the #scope method.
+          scope_chain[i].each do |scope_chain_item|
+            item  = eval_scope(klass, scope_chain_item, owner)
+
+            if scope_chain_item == refl.scope
+              scope.merge! item.except(:where, :includes, :bind)
+            end
+
+            if is_first_chain
+              scope.includes! item.includes_values
+            end
+
+            scope.where_values += item.where_values
+            scope.bind_values  += item.bind_values
+            scope.order_values |= item.order_values
+          end
+        end
+
+        scope
+      end
+    end
+  end
+end
+