sunstone 5.1.0.4 → 6.1.0.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: d53af8c7411662e7621971b1c2a3f39f130ea8c3
-  data.tar.gz: 8a61637315c7faf35265b47b8334901340b41798
+SHA256:
+  metadata.gz: afae21d218aa760e3a36c2db071a80f25f825fb618f56c9bc9cb25ddb628ee23
+  data.tar.gz: a1b4c27957ba0330a74bab059b5b352c56d74eeafd0d9e910845badae194a0e5
 SHA512:
-  metadata.gz: 690936bd2ba33aab551c98da50ea1871e29fdfa9207dd71c7bcd78050bfa56f219ad859c068ac33346833ffb44feb058bc2f41a46ab7c2e4f70b11c0f1449a62
-  data.tar.gz: 6e9f804cc2b2e75584e184b9791dc3f5b2d0d682c71cd5ef1c60cb4ffdf1af23b6607bf3f650be218acb87f0173dad53b2621fffa3aa9dac40f72fc51efc4663
+  metadata.gz: 2bf28e210e209846f11c287b7153669721211b86e1e27de9388b52bbdeb37abe1ea53c8370abfc11ab50132275804796912eeeb67c0c4e83cd840f54be44634b
+  data.tar.gz: b0eb0399c0a7ff542d06b9b3b83a1dbc699d4de11b75e24813186fd6f6c6de375713903ecc4886efb6b78395bc44f77841238d365ec389ada64bfeca95449626

data/.travis.yml

@@ -1,3 +1,4 @@
+dist: bionic
 language: ruby
 sudo: false
 
@@ -7,30 +8,42 @@ cache:
     - /home/travis/.rvm/gems
 
 rvm:
-  - 2.4.1
+  - 2.7
 
 env:
   matrix:
-    - RAILS_VERSION=v5.1.0 GEM=ar:mysql2
-    - RAILS_VERSION=v5.1.0 GEM=ar:sqlite3
-    - RAILS_VERSION=v5.1.0 GEM=ar:postgresql
-    - RAILS_VERSION=v5.1.1 GEM=ar:mysql2
-    - RAILS_VERSION=v5.1.1 GEM=ar:sqlite3
-    - RAILS_VERSION=v5.1.1 GEM=ar:postgresql
-    - RAILS_VERSION=v5.1.2 GEM=ar:mysql2
-    - RAILS_VERSION=v5.1.2 GEM=ar:sqlite3
-    - RAILS_VERSION=v5.1.2 GEM=ar:postgresql
-    - RAILS_VERSION=v5.1.3 GEM=ar:mysql2
-    - RAILS_VERSION=v5.1.3 GEM=ar:sqlite3
-    - RAILS_VERSION=v5.1.3 GEM=ar:postgresql
+    - RAILS_VERSION=v6.1.0 TASK='db:mysql:rebuild mysql2:test'
+    - RAILS_VERSION=v6.1.0 TASK='db:mysql:rebuild mysql2:isolated_test'
+    - RAILS_VERSION=v6.1.0 TASK='db:postgresql:rebuild postgresql:test'
+    - RAILS_VERSION=v6.1.0 TASK='db:postgresql:rebuild postgresql:isolated_test'
+    - RAILS_VERSION=v6.1.0 TASK='sqlite3:test'
+    - RAILS_VERSION=v6.1.0 TASK='sqlite3:isolated_test'
+    - RAILS_VERSION=v6.1.0 TASK='sqlite3_mem:test'
 
+services:
+  - mysql
 addons:
-  postgresql: "9.4"
+  postgresql: "13"
+  apt:
+    packages:
+    - postgresql-13
+    - postgresql-client-13
+
 
 before_install:
+  - sudo sed -i 's/port = 5433/port = 5432/' /etc/postgresql/13/main/postgresql.conf
+  - sudo cp /etc/postgresql/{9.3,13}/main/pg_hba.conf
+  - sudo pg_ctlcluster 13 main restart
   - unset BUNDLE_GEMFILE
   - gem update --system
   - gem update bundler
+  - gem install bundler --version 1.17.3
+  - mysql -e "create user rails@localhost;"
+  - mysql -e "grant all privileges on activerecord_unittest.* to rails@localhost;"
+  - mysql -e "grant all privileges on activerecord_unittest2.* to rails@localhost;"
+  - mysql -e "grant all privileges on inexistent_activerecord_unittest.* to rails@localhost;"
+  - mysql -e "create database activerecord_unittest default character set utf8mb4;"
+  - mysql -e "create database activerecord_unittest2 default character set utf8mb4;"
 
 install:
   - git clone --branch $RAILS_VERSION https://github.com/rails/rails.git ~/build/rails
@@ -52,4 +65,4 @@ before_script:
 
 script:
   - bundle exec rake test
-  - cd ~/build/rails && ci/travis.rb
+  - cd ~/build/rails/activerecord && bundle exec rake $TASK

data/ext/active_record/associations.rb

@@ -3,12 +3,7 @@ require 'active_record/associations'
 module ActiveRecord
   module Associations
     module ClassMethods
-      def has_and_belongs_to_many(name, scope = nil, options = {}, &extension)
-        if scope.is_a?(Hash)
-          options = scope
-          scope   = nil
-        end
-
+      def has_and_belongs_to_many(name, scope = nil, **options, &extension)
         habtm_reflection = ActiveRecord::Reflection::HasAndBelongsToManyReflection.new(name, scope, options, self)
 
         builder = Builder::HasAndBelongsToMany.new name, self, options
@@ -40,12 +35,12 @@ module ActiveRecord
         hm_options[:through] = middle_reflection.name
         hm_options[:source] = join_model.right_reflection.name
 
-        [:before_add, :after_add, :before_remove, :after_remove, :autosave, :validate, :join_table, :class_name, :extend].each do |k|
+        [:before_add, :after_add, :before_remove, :after_remove, :autosave, :validate, :join_table, :class_name, :extend, :strict_loading].each do |k|
           hm_options[k] = options[k] if options.key? k
         end
 
-        has_many name, scope, hm_options, &extension
-        self._reflections[name.to_s].parent_reflection = habtm_reflection
+        has_many name, scope, **hm_options, &extension
+        _reflections[name.to_s].parent_reflection = habtm_reflection
       end
     end
   end

data/ext/active_record/associations/collection_association.rb

@@ -9,17 +9,24 @@ module ActiveRecord
         if owner.new_record?
           replace_records(other_array, original_target)
         elsif owner.class.connection.is_a?(ActiveRecord::ConnectionAdapters::SunstoneAPIAdapter) && owner.instance_variable_defined?(:@updating) && owner.instance_variable_get(:@updating)
-          self.instance_variable_set(:@sunstone_changed, true)
           replace_common_records_in_memory(other_array, original_target)
 
           # Remove from target
-          (original_target - other_array).each { |record| callback(:before_remove, record) }
-          (original_target - other_array).each { |record| target.delete(record) }
-          (original_target - other_array).each { |record| callback(:after_remove, record) }
+          records_for_removal = (original_target - other_array)
+          if !records_for_removal.empty?
+            self.instance_variable_set(:@sunstone_changed, true)
+            records_for_removal.each { |record| callback(:before_remove, record) }
+            records_for_removal.each { |record| target.delete(record) }
+            records_for_removal.each { |record| callback(:after_remove, record) }
+          end
 
           # Add to target
-          (other_array - original_target).each do |record|
-            add_to_target(record)
+          records_for_addition = (other_array - original_target)
+          if !records_for_addition.empty?
+            self.instance_variable_set(:@sunstone_changed, true)
+            (other_array - original_target).each do |record|
+              add_to_target(record)
+            end
           end
 
           other_array
@@ -33,28 +40,28 @@ module ActiveRecord
         end
       end
 
-
-    end
-
-    class HasManyAssociation
-
-      def insert_record(record, validate = true, raise = false)
-        set_owner_attributes(record)
-        set_inverse_instance(record)
-
+      def insert_record(record, validate = true, raise = false, &block)
         if record.class.connection.is_a?(ActiveRecord::ConnectionAdapters::SunstoneAPIAdapter) && (!owner.instance_variable_defined?(:@updating) && owner.instance_variable_get(:@updating))
           true
         elsif raise
-          record.save!(:validate => validate)
+          record.save!(validate: validate, &block)
         else
-          record.save(:validate => validate)
+          record.save(validate: validate, &block)
         end
       end
 
+
+    end
+
+    class HasManyThroughAssociation
+
       private
       def save_through_record(record)
         return if record.class.connection.is_a?(ActiveRecord::ConnectionAdapters::SunstoneAPIAdapter)
-        build_through_record(record).save!
+        association = build_through_record(record)
+        if association.changed?
+          association.save!
+        end
       ensure
         @through_records.delete(record.object_id)
       end

data/ext/active_record/attribute_methods.rb

@@ -5,26 +5,23 @@ module ActiveRecord
     
     # Returns a Hash of the Arel::Attributes and attribute values that have been
     # typecasted for use in an Arel insert/update method.
-    def arel_attributes_with_values(attribute_names)
-      attrs = {}
-      arel_table = self.class.arel_table
-      
-      attribute_names.each do |name|
-        attrs[arel_table[name]] = typecasted_attribute_value(name)
+    def attributes_with_values(attribute_names)
+      attrs = attribute_names.index_with do |name|
+        _read_attribute(name)
       end
 
       if self.class.connection.is_a?(ActiveRecord::ConnectionAdapters::SunstoneAPIAdapter)
         self.class.reflect_on_all_associations.each do |reflection|
           if reflection.belongs_to?
             if association(reflection.name).loaded? && association(reflection.name).target == Thread.current[:sunstone_updating_model]
-              attrs.delete(arel_table[reflection.foreign_key])
+              attrs.delete(reflection.foreign_key)
             else
               add_attributes_for_belongs_to_association(reflection, attrs)
             end
           elsif reflection.has_one?
             add_attributes_for_has_one_association(reflection, attrs)
           elsif reflection.collection?
-            add_attributes_for_collection_association(reflection, attrs, arel_table)
+            add_attributes_for_collection_association(reflection, attrs, self.class.arel_table)
           end
         end
       end
@@ -49,15 +46,7 @@ module ActiveRecord
           record.destroy
         elsif autosave != false
           if record.new_record? || (autosave && record.changed_for_autosave?)
-            if record.new_record?
-              record.send(:arel_attributes_with_values_for_create, record.attribute_names).each do |k, v|
-                attrs[Arel::Attributes::Relation.new(k, reflection.name, false, true)] = v
-              end
-            else
-              record.send(:arel_attributes_with_values_for_update, record.attribute_names).each do |k, v|
-                attrs[Arel::Attributes::Relation.new(k, reflection.name, false, true)] = v
-              end
-            end
+            attrs["#{reflection.name}_attributes"] = record.send(:attributes_with_values, record.new_record? ? (record.attribute_names - ['id']) : record.attribute_names)
           end
         end
       end
@@ -86,15 +75,7 @@ module ActiveRecord
               record[reflection.foreign_key] = key
             end
 
-            if record.new_record?
-              record.send(:arel_attributes_with_values_for_create, record.attribute_names).each do |k, v|
-                attrs[Arel::Attributes::Relation.new(k, reflection.name, false, true)] = v
-              end
-            else
-              record.send(:arel_attributes_with_values_for_update, record.attribute_names).each do |k, v|
-                attrs[Arel::Attributes::Relation.new(k, reflection.name, false, true)] = v
-              end
-            end
+            attrs["#{reflection.name}_attributes"] = record.send(:attributes_with_values, record.new_record? ? (record.attribute_names - ['id']): record.attribute_names)
           end
         end
       end
@@ -111,22 +92,15 @@ module ActiveRecord
       end
 
       if association = association_instance_get(reflection.name)
-        if new_record? || (association.instance_variable_defined?(:@sunstone_changed) && association.instance_variable_get(:@sunstone_changed)) || reflection.options[:autosave] || association.target.any?(&:changed_for_autosave?) || association.target.any?(&:new_record?)
-          attrs[Arel::Attributes::EmptyRelation.new(arel_table, reflection.name, true, true)] = [] if association.target.empty?
-        
-          association.target.each_with_index do |record, idx|
-            next if record.destroyed?
-
-            if record.new_record?
-              record.send(:arel_attributes_with_values_for_create, record.send(:keys_for_partial_write) + [record.class.primary_key]).each do |k, v|
-                attrs[Arel::Attributes::Relation.new(k, reflection.name, idx, true)] = v
-              end
-            else
-              record.send(:arel_attributes_with_values_for_update, record.send(:keys_for_partial_write) + [record.class.primary_key]).each do |k, v|
-                attrs[Arel::Attributes::Relation.new(k, reflection.name, idx, true)] = v
-              end
+        if new_record? || (association.instance_variable_defined?(:@sunstone_changed) && association.instance_variable_get(:@sunstone_changed)) || association.target.any?(&:changed_for_autosave?) || association.target.any?(&:new_record?)
+          attrs["#{reflection.name}_attributes"] = if association.target.empty?
+            []
+          else
+            association.target.select { |r| !r.destroyed? }.map do |record|
+              record.send(:attributes_with_values, record.send(:attribute_names_for_partial_writes) + (record.new_record? ? [] : [record.class.primary_key]))
             end
           end
+        
           association.instance_variable_set(:@sunstone_changed, false)
         end
 
@@ -134,8 +108,6 @@ module ActiveRecord
         association.reset_scope if association.respond_to?(:reset_scope)
       end
     end
-
-
     
   end
 end

data/ext/active_record/callbacks.rb

@@ -2,7 +2,7 @@ module ActiveRecord
   module Callbacks
     private
 
-      def create_or_update(*) #:nodoc:
+      def create_or_update(**) #:nodoc:
         if self.class.connection.is_a?(ActiveRecord::ConnectionAdapters::SunstoneAPIAdapter)
           @_already_called ||= {}
           self.class.reflect_on_all_associations.each do |r|

data/ext/active_record/finder_methods.rb

@@ -1,25 +1,13 @@
-module Arel
-  module Visitors
-    class ToSql < Arel::Visitors::Reduce
-      
-      def visit_Arel_Attributes_Relation o, collector
-        visit(o.relation, collector)
-      end
-      
-    end
-  end
-end
-
 module ActiveRecord
   class PredicateBuilder # :nodoc:
 
-    def expand_from_hash(attributes)
+    def expand_from_hash(attributes, &block)
       return ["1=0"] if attributes.empty?
   
       attributes.flat_map do |key, value|
-        if value.is_a?(Hash)
-          ka = associated_predicate_builder(key).expand_from_hash(value)
-          if self.table.instance_variable_get(:@klass).connection.is_a?(ActiveRecord::ConnectionAdapters::SunstoneAPIAdapter)
+        if value.is_a?(Hash) && !table.has_column?(key)
+          ka = table.associated_table(key, &block).predicate_builder.expand_from_hash(value.stringify_keys)
+          if self.send(:table).instance_variable_get(:@klass).connection.is_a?(ActiveRecord::ConnectionAdapters::SunstoneAPIAdapter)
             ka.each { |k|
               if k.left.is_a?(Arel::Attributes::Attribute) || k.left.is_a?(Arel::Attributes::Relation)
                 k.left = Arel::Attributes::Relation.new(k.left, key)
@@ -27,8 +15,51 @@ module ActiveRecord
             }
           end
           ka
+        elsif table.associated_with?(key)
+          # Find the foreign key when using queries such as:
+          # Post.where(author: author)
+          #
+          # For polymorphic relationships, find the foreign key and type:
+          # PriceEstimate.where(estimate_of: treasure)
+          associated_table = table.associated_table(key)
+          if associated_table.polymorphic_association?
+            case value.is_a?(Array) ? value.first : value
+            when Base, Relation
+              value = [value] unless value.is_a?(Array)
+              klass = PolymorphicArrayValue
+            end
+          elsif associated_table.through_association?
+            next associated_table.predicate_builder.expand_from_hash(
+              associated_table.primary_key => value
+            )
+          end
+
+          klass ||= AssociationQueryValue
+          queries = klass.new(associated_table, value).queries.map! do |query|
+            expand_from_hash(query)
+          end
+
+          grouping_queries(queries)
+        elsif table.aggregated_with?(key)
+          mapping = table.reflect_on_aggregation(key).mapping
+          values = value.nil? ? [nil] : Array.wrap(value)
+          if mapping.length == 1 || values.empty?
+            column_name, aggr_attr = mapping.first
+            values = values.map do |object|
+              object.respond_to?(aggr_attr) ? object.public_send(aggr_attr) : object
+            end
+            self[column_name, values]
+          else
+            queries = values.map do |object|
+              mapping.map do |field_attr, aggregate_attr|
+                self[field_attr, object.try!(aggregate_attr)]
+              end
+            end
+
+            grouping_queries(queries)
+          end
         else
-          build(table.arel_attribute(key), value)
+          self[key, value]
         end
       end
     end
@@ -39,98 +70,113 @@ end
 module ActiveRecord
   module FinderMethods
 
-    def find_with_associations
-      join_dependency = nil
-      aliases = nil
-      relation = if connection.is_a?(ActiveRecord::ConnectionAdapters::SunstoneAPIAdapter)
-        arel.eager_load = Arel::Nodes::EagerLoad.new(eager_load_values)
-        self
-      else
-        join_dependency = construct_join_dependency(joins_values)
-        aliases  = join_dependency.aliases
-        apply_join_dependency(select(aliases.columns), join_dependency)
+    class SunstoneJoinDependency
+      def initialize(klass)
+        @klass = klass
       end
       
-      if block_given?
-        yield relation
-      else
-        if ActiveRecord::NullRelation === relation
-          []
-        else
-          arel = relation.arel
-          rows = if connection.is_a?(ActiveRecord::ConnectionAdapters::SunstoneAPIAdapter)
-            connection.select_all(arel, 'SQL', arel.bind_values + relation.bound_attributes)
-          else
-            connection.select_all(arel, 'SQL', relation.bound_attributes)
-          end
-          if join_dependency
-            join_dependency.instantiate(rows, aliases)
-          else
-            instantiate_with_associations(rows, relation)
-          end
-        end
+      def reflections
+        []
       end
-    end
+      
+      def apply_column_aliases(relation)
+        relation
+      end
+      
+      def instantiate(result_set, strict_loading_value, &block)
+        seen = Hash.new { |i, object_id|
+          i[object_id] = Hash.new { |j, child_class|
+            j[child_class] = {}
+          }
+        }
+
+        model_cache = Hash.new { |h, klass| h[klass] = {} }
+        parents = model_cache[@klass]
 
-    def instantiate_with_associations(result_set, klass)
-      seen = Hash.new { |h, parent_klass|
-        h[parent_klass] = Hash.new { |i, parent_id|
-          i[parent_id] = Hash.new { |j, child_klass| j[child_klass] = {} }
+        message_bus = ActiveSupport::Notifications.instrumenter
+
+        payload = {
+          record_count: result_set.length,
+          class_name: @klass.name
         }
-      }
 
-      model_cache = Hash.new { |h,kklass| h[kklass] = {} }
-      parents = model_cache[self.base_class]
+        message_bus.instrument("instantiation.active_record", payload) do
+          result_set.each { |row_hash|
+            parent_key = @klass.primary_key ? row_hash[@klass.primary_key] : row_hash
+            parent = parents[parent_key] ||= @klass.instantiate(row_hash.select{|k,v| @klass.column_names.include?(k.to_s) }, &block)
+            construct(parent, row_hash.select{|k,v| !@klass.column_names.include?(k.to_s) }, seen, model_cache, strict_loading_value)
+          }
+        end
 
-      result_set.each { |row_hash|
-        parent = parents[row_hash[primary_key]] ||= instantiate(row_hash.select{|k,v| column_names.include?(k.to_s) })
-        construct(parent, row_hash.select{|k,v| !column_names.include?(k.to_s) }, seen, model_cache)
-      }
+        parents.values
+      end
 
-      parents.values
-    end
+      def construct(parent, relations, seen, model_cache, strict_loading_value)
+        relations.each do |key, attributes|
+          reflection = parent.class.reflect_on_association(key)
+          next unless reflection
 
-    def construct(parent, relations, seen, model_cache)
-      relations.each do |key, attributes|
-        reflection = parent.class.reflect_on_association(key)
-        next unless reflection
+          if reflection.collection?
+            other = parent.association(reflection.name)
+            other.loaded!
+          else
+            if parent.association_cached?(reflection.name)
+              model = parent.association(reflection.name).target
+              construct(model, attributes.select{|k,v| !model.class.column_names.include?(k.to_s) }, seen, model_cache, strict_loading_value)
+            end
+          end
 
-        if reflection.collection?
-          other = parent.association(reflection.name)
-          other.loaded!
-        else
-          if parent.association_cached?(reflection.name)
-            model = parent.association(reflection.name).target
-            construct(model, attributes.select{|k,v| !model.class.column_names.include?(k.to_s) }, seen, model_cache)
+          if !reflection.collection?
+            construct_association(parent, reflection, attributes, seen, model_cache, strict_loading_value)
+          else
+            attributes.each do |row|
+              construct_association(parent, reflection, row, seen, model_cache, strict_loading_value)
+            end
           end
+
         end
+      end
 
-        if !reflection.collection?
-          construct_association(parent, reflection, attributes, seen, model_cache)
+      def construct_association(parent, reflection, attributes, seen, model_cache, strict_loading_value)
+        return if attributes.nil?
+
+        klass = if reflection.polymorphic?
+          parent.send(reflection.foreign_type).constantize.base_class
         else
-          attributes.each do |row|
-            construct_association(parent, reflection, row, seen, model_cache)
-          end
+          reflection.klass
         end
+        id = attributes[klass.primary_key]
+        model = seen[parent.object_id][klass][id]
 
-      end
-    end
+        if model
+          construct(model, attributes.select{|k,v| !klass.column_names.include?(k.to_s) }, seen, model_cache, strict_loading_value)
 
-    def construct_association(parent, reflection, attributes, seen, model_cache)
-      return if attributes.nil?
+          other = parent.association(reflection.name)
 
-      klass = if reflection.polymorphic?
-        parent.send(reflection.foreign_type).constantize.base_class
-      else
-        reflection.klass
+          if reflection.collection?
+            other.target.push(model)
+          else
+            other.target = model
+          end
+
+          other.set_inverse_instance(model)
+        else
+          model = construct_model(parent, reflection, id, attributes.select{|k,v| klass.column_names.include?(k.to_s) }, seen, model_cache, strict_loading_value)
+          seen[parent.object_id][model.class.base_class][id] = model
+          construct(model, attributes.select{|k,v| !klass.column_names.include?(k.to_s) }, seen, model_cache, strict_loading_value)
+        end
       end
-      id = attributes[klass.primary_key]
-      model = seen[parent.class.base_class][parent.id][klass][id]
 
-      if model
-        construct(model, attributes.select{|k,v| !klass.column_names.include?(k.to_s) }, seen, model_cache)
 
-        other = parent.association(reflection.name)
+      def construct_model(record, reflection, id, attributes, seen, model_cache, strict_loading_value)
+        klass = if reflection.polymorphic?
+          record.send(reflection.foreign_type).constantize
+        else
+          reflection.klass
+        end
+
+        model = model_cache[klass][id] ||= klass.instantiate(attributes)
+        other = record.association(reflection.name)
 
         if reflection.collection?
           other.target.push(model)
@@ -139,34 +185,46 @@ module ActiveRecord
         end
 
         other.set_inverse_instance(model)
-      else
-        model = construct_model(parent, reflection, id, attributes.select{|k,v| klass.column_names.include?(k.to_s) }, seen, model_cache)
-        seen[parent.class.base_class][parent.id][model.class.base_class][id] = model
-        construct(model, attributes.select{|k,v| !klass.column_names.include?(k.to_s) }, seen, model_cache)
+        model
       end
+  
     end
 
-
-    def construct_model(record, reflection, id, attributes, seen, model_cache)
-      klass = if reflection.polymorphic?
-        record.send(reflection.foreign_type).constantize
+    def apply_join_dependency(eager_loading: group_values.empty?)
+      if connection.is_a?(ActiveRecord::ConnectionAdapters::SunstoneAPIAdapter)
+        join_dependency = SunstoneJoinDependency.new(base_class)
+        relation = except(:includes, :eager_load, :preload)
+        relation.arel.eager_load = Arel::Nodes::EagerLoad.new(eager_load_values)
       else
-        reflection.klass
+        join_dependency = construct_join_dependency(
+          eager_load_values | includes_values, Arel::Nodes::OuterJoin
+        )
+        relation = except(:includes, :eager_load, :preload).joins!(join_dependency)
       end
 
-      model = model_cache[klass][id] ||= klass.instantiate(attributes)
-      other = record.association(reflection.name)
+      if eager_loading && !(
+          using_limitable_reflections?(join_dependency.reflections) &&
+          using_limitable_reflections?(
+            construct_join_dependency(
+              select_association_list(joins_values).concat(
+                select_association_list(left_outer_joins_values)
+              ), nil
+            ).reflections
+          )
+      )
+        if has_limit_or_offset?
+          limited_ids = limited_ids_for(relation)
+          limited_ids.empty? ? relation.none! : relation.where!(primary_key => limited_ids)
+        end
+        relation.limit_value = relation.offset_value = nil
+      end
 
-      if reflection.collection?
-        other.target.push(model)
+      if block_given?
+        yield relation, join_dependency
       else
-        other.target = model
+        relation
       end
-
-      other.set_inverse_instance(model)
-      model
     end
-
   end
 
 end