sunstone 5.1.0.4 → 5.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: d53af8c7411662e7621971b1c2a3f39f130ea8c3
-  data.tar.gz: 8a61637315c7faf35265b47b8334901340b41798
+SHA256:
+  metadata.gz: f235687b97d48caa7ecf7a231928452bbaf807b8d2e6e6508a7f9159372dc600
+  data.tar.gz: 94eec63ac1c23762404058fe37b1558a62ec7ad564e262977e1534721949c149
 SHA512:
-  metadata.gz: 690936bd2ba33aab551c98da50ea1871e29fdfa9207dd71c7bcd78050bfa56f219ad859c068ac33346833ffb44feb058bc2f41a46ab7c2e4f70b11c0f1449a62
-  data.tar.gz: 6e9f804cc2b2e75584e184b9791dc3f5b2d0d682c71cd5ef1c60cb4ffdf1af23b6607bf3f650be218acb87f0173dad53b2621fffa3aa9dac40f72fc51efc4663
+  metadata.gz: c16d5374f32074dcd7a9e96ecf7f01dc6c77848df299454a5209913f25cdb23b333f4cc6b9a93e6f58d25b6681a11f54b8124f8352427702b22301e81a98a6a7
+  data.tar.gz: fb6512b92823f37cac2477010df776a703f12a3f13f455a6d7388c8edffe4a59192fa3aa2114b4f62e244aa4b9a771f32e01718e5c5f2a0ddf2ed382fe49390a

data/.travis.yml

@@ -7,22 +7,14 @@ cache:
     - /home/travis/.rvm/gems
 
 rvm:
-  - 2.4.1
+  - 2.4.4
+  - 2.5.1
 
 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=v5.2.0 GEM=ar:mysql2
+    - RAILS_VERSION=v5.2.0 GEM=ar:sqlite3
+    - RAILS_VERSION=v5.2.0 GEM=ar:postgresql
 
 addons:
   postgresql: "9.4"

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
@@ -45,7 +40,7 @@ module ActiveRecord
         end
 
         has_many name, scope, hm_options, &extension
-        self._reflections[name.to_s].parent_reflection = habtm_reflection
+        _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.each_with_object({}) do |name, attrs|
+        attrs[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
@@ -50,13 +47,9 @@ module ActiveRecord
         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
+              attrs["#{reflection.name}_attributes"] = record.send(:attributes_with_values_for_create, record.attribute_names)              
             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
+              attrs["#{reflection.name}_attributes"] = record.send(:attributes_with_values_for_update, record.attribute_names)
             end
           end
         end
@@ -87,13 +80,9 @@ module ActiveRecord
             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
+              attrs["#{reflection.name}_attributes"] = record.send(:attributes_with_values_for_create, record.attribute_names)
             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
+              attrs["#{reflection.name}_attributes"] = record.send(:attributes_with_values_for_update, record.attribute_names)
             end
           end
         end
@@ -111,22 +100,19 @@ 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
+        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|
+              if record.new_record?
+                record.send(:attributes_with_values_for_create, record.send(:keys_for_partial_write) + [record.class.primary_key])
+              else
+                record.send(:attributes_with_values_for_update, record.send(:keys_for_partial_write) + [record.class.primary_key])
               end
             end
           end
+        
           association.instance_variable_set(:@sunstone_changed, false)
         end
 
@@ -134,8 +120,6 @@ module ActiveRecord
         association.reset_scope if association.respond_to?(:reset_scope)
       end
     end
-
-
     
   end
 end

data/ext/active_record/finder_methods.rb

@@ -17,7 +17,7 @@ module ActiveRecord
       return ["1=0"] if attributes.empty?
   
       attributes.flat_map do |key, value|
-        if value.is_a?(Hash)
+        if value.is_a?(Hash) && !table.has_column?(key)
           ka = associated_predicate_builder(key).expand_from_hash(value)
           if self.table.instance_variable_get(:@klass).connection.is_a?(ActiveRecord::ConnectionAdapters::SunstoneAPIAdapter)
             ka.each { |k|
@@ -27,6 +27,38 @@ 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
+          end
+
+          klass ||= AssociationQueryValue
+          queries = klass.new(associated_table, value).queries.map do |query|
+            expand_from_hash(query).reduce(&:and)
+          end
+          queries.reduce(&:or)
+        elsif table.aggregated_with?(key)
+          mapping = table.reflect_on_aggregation(key).mapping
+          queries = Array.wrap(value).map do |object|
+            mapping.map do |field_attr, aggregate_attr|
+              if mapping.size == 1 && !object.respond_to?(aggregate_attr)
+                build(table.arel_attribute(field_attr), object)
+              else
+                build(table.arel_attribute(field_attr), object.send(aggregate_attr))
+              end
+            end.reduce(&:and)
+          end
+          queries.reduce(&:or)
         else
           build(table.arel_attribute(key), value)
         end
@@ -39,98 +71,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, &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]
+
+        message_bus = ActiveSupport::Notifications.instrumenter
 
-    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] = {} }
+        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)
+          }
+        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)
+        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)
+            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)
+          else
+            attributes.each do |row|
+              construct_association(parent, reflection, row, seen, model_cache)
+            end
           end
+
         end
+      end
+
+      def construct_association(parent, reflection, attributes, seen, model_cache)
+        return if attributes.nil?
 
-        if !reflection.collection?
-          construct_association(parent, reflection, attributes, seen, model_cache)
+        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)
 
-    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)
+          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)
+        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)
+        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 +186,35 @@ 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
+        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)
+        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