sunstone 6.0.0.5 → 6.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 87a052085f5f1445d0e6cdea630054ba3a17aa742b679c539a87f03af8f018ee
-  data.tar.gz: 50007447eb6c02ce55c90aebd7973190913f43183151a783eb9e3914c95e7ffc
+  metadata.gz: 67c26e8a4275aa67d9e09b43cfce417732142a043b6ca49d2c1e85bbfb74950d
+  data.tar.gz: a46c586fe763e9d90029a007074919fca9e997efa8ddddf57588136d6cb2b883
 SHA512:
-  metadata.gz: aef51f99ea18ba631bdfe4dcfd95ac2133ad3e721ef97251ba53151fe7f9c3076fb942580cdf147f796fa9c6d75f59efabd1bfb0964f550c8fd484de5f267a4b
-  data.tar.gz: 41786cdf195c547c7ec704c7dcd5e92c65e1441732e32da3adf3f8f13398baece163f583a7f953b3ea5ab7d411519643acb0b8acc27ec2d6aabad197f844dd3a
+  metadata.gz: 1fd7cb872485fa5507d1bcb21e28e81d92b807279fbdbf12440a74de32cd39c4584c42e6f0ea1fd371261a3c614358967d94c1abc30bb304b2364bb8ae7e9dab
+  data.tar.gz: 3d3105125dfaad25f7884648406444ca3a4dab3e2782b482659179ca8a484ce52bded0222af6b48210ad7f0f00c901ca92a3e780380b22d4b62cb3e3c57019f8

data/ext/active_record/associations.rb

@@ -35,11 +35,11 @@ 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
+        has_many name, scope, **hm_options, &extension
         _reflections[name.to_s].parent_reflection = habtm_reflection
       end
     end

data/ext/active_record/attribute_methods.rb

@@ -6,8 +6,8 @@ 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 attributes_with_values(attribute_names)
-      attrs = attribute_names.each_with_object({}) do |name, attrs|
-        attrs[name] = _read_attribute(name)
+      attrs = attribute_names.index_with do |name|
+        _read_attribute(name)
       end
 
       if self.class.connection.is_a?(ActiveRecord::ConnectionAdapters::SunstoneAPIAdapter)

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,24 +1,12 @@
-module Arel
-  module Visitors
-    class ToSql < Arel::Visitors::Visitor
-      
-      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) && !table.has_column?(key)
-          ka = associated_predicate_builder(key).expand_from_hash(value)
+          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)
@@ -40,13 +28,18 @@ module ActiveRecord
               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).reduce(&:and)
+          queries = klass.new(associated_table, value).queries.map! do |query|
+            expand_from_hash(query)
           end
-          queries.reduce(&:or)
+
+          grouping_queries(queries)
         elsif table.aggregated_with?(key)
           mapping = table.reflect_on_aggregation(key).mapping
           values = value.nil? ? [nil] : Array.wrap(value)
@@ -55,17 +48,18 @@ module ActiveRecord
             values = values.map do |object|
               object.respond_to?(aggr_attr) ? object.public_send(aggr_attr) : object
             end
-            build(table.arel_attribute(column_name), values)
+            self[column_name, values]
           else
             queries = values.map do |object|
               mapping.map do |field_attr, aggregate_attr|
-                build(table.arel_attribute(field_attr), object.try!(aggregate_attr))
-              end.reduce(&:and)
+                self[field_attr, object.try!(aggregate_attr)]
+              end
             end
-            queries.reduce(&:or)
+
+            grouping_queries(queries)
           end
         else
-          build(table.arel_attribute(key), value)
+          self[key, value]
         end
       end
     end
@@ -89,7 +83,7 @@ module ActiveRecord
         relation
       end
       
-      def instantiate(result_set, &block)
+      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] = {}
@@ -110,14 +104,14 @@ module ActiveRecord
           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)
+            construct(parent, row_hash.select{|k,v| !@klass.column_names.include?(k.to_s) }, seen, model_cache, strict_loading_value)
           }
         end
 
         parents.values
       end
 
-      def construct(parent, relations, seen, model_cache)
+      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
@@ -128,22 +122,22 @@ module ActiveRecord
           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)
+              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?
-            construct_association(parent, reflection, attributes, seen, model_cache)
+            construct_association(parent, reflection, attributes, seen, model_cache, strict_loading_value)
           else
             attributes.each do |row|
-              construct_association(parent, reflection, row, seen, model_cache)
+              construct_association(parent, reflection, row, seen, model_cache, strict_loading_value)
             end
           end
 
         end
       end
 
-      def 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?
@@ -155,7 +149,7 @@ module ActiveRecord
         model = seen[parent.object_id][klass][id]
 
         if model
-          construct(model, attributes.select{|k,v| !klass.column_names.include?(k.to_s) }, seen, model_cache)
+          construct(model, attributes.select{|k,v| !klass.column_names.include?(k.to_s) }, seen, model_cache, strict_loading_value)
 
           other = parent.association(reflection.name)
 
@@ -167,14 +161,14 @@ module ActiveRecord
 
           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)
+          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)
+          construct(model, attributes.select{|k,v| !klass.column_names.include?(k.to_s) }, seen, model_cache, strict_loading_value)
         end
       end
 
 
-      def construct_model(record, reflection, id, attributes, seen, model_cache)
+      def construct_model(record, reflection, id, attributes, seen, model_cache, strict_loading_value)
         klass = if reflection.polymorphic?
           record.send(reflection.foreign_type).constantize
         else
@@ -202,12 +196,23 @@ module ActiveRecord
         relation = except(:includes, :eager_load, :preload)
         relation.arel.eager_load = Arel::Nodes::EagerLoad.new(eager_load_values)
       else
-        join_dependency = construct_join_dependency(eager_load_values + includes_values)
+        join_dependency = construct_join_dependency(
+          eager_load_values | includes_values, Arel::Nodes::OuterJoin
+        )
         relation = except(:includes, :eager_load, :preload).joins!(join_dependency)
       end
 
-      if eager_loading && !using_limitable_reflections?(join_dependency.reflections)
-        if has_limit_or_offset?
+      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? && !connection.is_a?(ActiveRecord::ConnectionAdapters::SunstoneAPIAdapter)
           limited_ids = limited_ids_for(relation)
           limited_ids.empty? ? relation.none! : relation.where!(primary_key => limited_ids)
         end
@@ -220,6 +225,7 @@ module ActiveRecord
         relation
       end
     end
+    
   end
 
 end

data/ext/active_record/persistence.rb

@@ -105,6 +105,8 @@ module ActiveRecord
         @_trigger_update_callback = affected_rows == 1
       end
 
+      @previously_new_record = false
+
       yield(self) if block_given?
 
       affected_rows

data/ext/active_record/relation/calculations.rb

@@ -5,13 +5,13 @@ module ActiveRecord
       if loaded? && (column_names.map(&:to_s) - @klass.attribute_names - @klass.attribute_aliases.keys).empty?
         return records.pluck(*column_names)
       end
-
+      
       if has_include?(column_names.first)
         relation = apply_join_dependency
         relation.pluck(*column_names)
       elsif klass.connection.is_a?(ActiveRecord::ConnectionAdapters::SunstoneAPIAdapter)
         load
-        return records.pluck(*column_names.map{|n| n.sub(/^#{klass.table_name}\./, "")})
+        return records.pluck(*column_names.map{|n| n.to_s.sub(/^#{klass.table_name}\./, "")})
       else
         klass.disallow_raw_sql!(column_names)
         relation = spawn

data/ext/active_record/statement_cache.rb

@@ -5,10 +5,9 @@ module ActiveRecord
       def initialize(values, sunstone=false)
         @values = values
         @indexes = if sunstone
-          
         else
-          values.each_with_index.find_all { |thing,i|
-            Arel::Nodes::BindParam === thing
+          values.each_with_index.find_all { |thing, i|
+            Substitute === thing
           }.map(&:last)
         end
       end
@@ -19,8 +18,13 @@ module ActiveRecord
           @values
         else
           val = @values.dup
-          casted_binds = binds.map(&:value_for_database)
-          @indexes.each { |i| val[i] = connection.quote(casted_binds.shift) }
+          @indexes.each do |i|
+            value = binds.shift
+            if ActiveModel::Attribute === value
+              value = value.value_for_database
+            end
+            val[i] = connection.quote(value)
+          end
           val.join
         end
       end

data/ext/active_record/transactions.rb

@@ -20,7 +20,7 @@ module ActiveRecord
     #   end
     # end
     #
-    def save!(*) #:nodoc:
+    def save!(**) #:nodoc:
       if instance_variable_defined?(:@no_save_transaction) && @no_save_transaction
         super
       else
@@ -35,29 +35,22 @@ module ActiveRecord
 
     def with_transaction_returning_status
       status = nil
+      connection = self.class.connection
       
-      if self.class.connection.is_a?(ActiveRecord::ConnectionAdapters::SunstoneAPIAdapter) && instance_variable_defined?(:@updating) && @updating
+      if connection.is_a?(ActiveRecord::ConnectionAdapters::SunstoneAPIAdapter) && instance_variable_defined?(:@updating) && @updating
         status = yield
-        status
       else
-        self.class.transaction do
-          if has_transactional_callbacks?
-            add_to_transaction
-          else
-            sync_with_transaction_state if @transaction_state&.finalized?
-            @transaction_state = self.class.connection.transaction_state
-          end
+        ensure_finalize = !connection.transaction_open?
+        connection.transaction do
+          add_to_transaction(ensure_finalize || has_transactional_callbacks?)
           remember_transaction_record_state
 
           status = yield
           raise ActiveRecord::Rollback unless status
         end
-        status
-      end
-    ensure
-      if @transaction_state && @transaction_state.committed?
-        clear_transaction_record_state
       end
+      
+      status
     end
 
 

data/ext/arel/attributes/empty_relation.rb

@@ -1,31 +1,31 @@
-module Arel
-  module Attributes
-    class EmptyRelation < Attribute
-
-      attr_accessor :collection, :for_write
-
-      def initialize(relation, name, collection = false, for_write=false)
-        self[:relation] = relation
-        self[:name] = name
-        @collection = collection
-        @for_write = for_write
-      end
-
-      def able_to_type_cast?
-        false
-      end
-
-      def table_name
-        nil
-      end
-
-      def eql? other
-        self.class == other.class &&
-          self.relation == other.relation &&
-          self.name == other.name &&
-          self.collection == other.collection
-      end
-
-    end
-  end
-end
+# module Arel
+#   module Attributes
+#     class EmptyRelation < Attribute
+#
+#       attr_accessor :collection, :for_write
+#
+#       def initialize(relation, name, collection = false, for_write=false)
+#         self[:relation] = relation
+#         self[:name] = name
+#         @collection = collection
+#         @for_write = for_write
+#       end
+#
+#       def able_to_type_cast?
+#         false
+#       end
+#
+#       def table_name
+#         nil
+#       end
+#
+#       def eql? other
+#         self.class == other.class &&
+#           self.relation == other.relation &&
+#           self.name == other.name &&
+#           self.collection == other.collection
+#       end
+#
+#     end
+#   end
+# end

data/ext/arel/nodes/select_statement.rb

@@ -4,7 +4,7 @@ module Arel
 
       attr_accessor :eager_load
 
-      def initialize cores = [SelectCore.new]
+      def initialize(cores = [SelectCore.new])
         super()
         @cores          = cores
         @orders         = []

data/lib/active_record/connection_adapters/sunstone/column.rb

@@ -2,18 +2,18 @@ module ActiveRecord
   module ConnectionAdapters
     # Sunstone-specific extensions to column definitions in a table.
     class SunstoneColumn < Column #:nodoc:
-      delegate :array, to: :sql_type_metadata
-      alias :array? :array
+      attr_reader :array
       
       def initialize(name, sql_type_metadata, options={})
         @name = name.freeze
         @sql_type_metadata = sql_type_metadata
         @null = options['null']
-        @default = options['default']
+        @default = (sql_type_metadata.type == :json ? JSON.generate(options['default']) : options['default'])
         @default_function = nil
         @collation = nil
         @table_name = nil
         @primary_key = (options['primary_key'] == true)
+        @array = options['array']
       end
       
       def primary_key?

data/lib/active_record/connection_adapters/sunstone/database_statements.rb

@@ -47,15 +47,15 @@ module ActiveRecord
         # can be used to query the database repeatedly.
         def cacheable_query(klass, arel) # :nodoc:
           if prepared_statements
-            sql, binds = visitor.accept(arel.ast, collector).value
+            sql, binds = visitor.compile(arel.ast, collector)
             query = klass.query(sql)
           elsif self.is_a?(ActiveRecord::ConnectionAdapters::SunstoneAPIAdapter)
             collector = SunstonePartialQueryCollector.new(self.collector)
-            parts, binds = visitor.accept(arel.ast, collector).value
+            parts, binds = visitor.compile(arel.ast, collector)
             query = StatementCache::PartialQuery.new(parts, true)
           else
-            collector = PartialQueryCollector.new
-            parts, binds = visitor.accept(arel.ast, collector).value
+            collector = klass.partial_query_collector
+            parts, binds = visitor.compile(arel.ast, collector)
             query = klass.partial_query(parts)
           end
           [query, binds]
@@ -142,7 +142,7 @@ module ActiveRecord
           
           if sars[0].instance_variable_defined?(:@sunstone_calculation) && sars[0].instance_variable_get(:@sunstone_calculation)
             # this is a count, min, max.... yea i know..
-            ActiveRecord::Result.new(['all'], [result], {:all => type_map.lookup('integer')})
+            ActiveRecord::Result.new(['all'], [result], {:all => type_map.lookup('integer', {})})
           elsif result.is_a?(Array)
             ActiveRecord::Result.new(result[0] ? result[0].keys : [], result.map{|r| r.values})
           else