sunstone 6.0.0.4 → 6.1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5ecbeb6967817d2f58c9602526839eeee2b9aa161dc00adf1f962549874c49af
-  data.tar.gz: 7759fa8e537ae1dd04009dca78ae7ffad19cbb6166629e99778f2b22aa982837
+  metadata.gz: 70fcfa3e9252509421cfb640f2f0ea0294c37018f6b8a9feeaf4fcb2f9d75161
+  data.tar.gz: 9dd9af70b45187707817193f5632302005e8e0ede8a8c146db6fae567c706e84
 SHA512:
-  metadata.gz: c72e778804a92ea85dadd3f7adbae2f5171ca63c47da09b065dcb9c14202a8d78e9ecd95ad15f7b2f0bfe7384a858497a1758b056112f703cc87fb8dd91607dd
-  data.tar.gz: 26d94406a0f9b50ad8429c0dd5d49d3da1fd182e1b8b12d87d6e0f0604f343f0920a10b6f0597b4830e3d6856cf62e36b65382e081381f6d5e9b196e94f28c72
+  metadata.gz: ac6d53c45d04cf82a891aa9bf736f69492e76847a3748aeecdda6830da80ae04f43f4e9fd981467627d301726ac2459f4297200a57ce917f48b35dc2e8734101
+  data.tar.gz: d7db042c9710800367267f124d7abc33814ce638409200a080e7c1e27e99e78b41cd84a22dbc160ec2d7c7f739df77cca0bec77b17d92b672c1ae9f69db5dc1b

data/.travis.yml

@@ -1,4 +1,4 @@
-dist: xenial
+dist: bionic
 language: ruby
 sudo: false
 
@@ -8,23 +8,42 @@ cache:
     - /home/travis/.rvm/gems
 
 rvm:
-  - 2.6
+  - 2.7
+  - 3.0
 
 env:
   matrix:
-    - RAILS_VERSION=v6.0.0.rc1 GEM=activerecord:mysql2
-    - RAILS_VERSION=v6.0.0.rc1 GEM=activerecord:sqlite3
-    - RAILS_VERSION=v6.0.0.rc1 GEM=activerecord: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: "10"
+  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
@@ -46,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

@@ -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,11 +196,22 @@ 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 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)

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

@@ -2,7 +2,7 @@ module ActiveRecord
   module Calculations
     
     def pluck(*column_names)
-      if loaded? && (column_names.map(&:to_s) - @klass.attribute_names - @klass.attribute_aliases.keys).empty?
+      if loaded? && all_attributes?(column_names)
         return records.pluck(*column_names)
       end
 
@@ -14,10 +14,18 @@ module ActiveRecord
         return records.pluck(*column_names.map{|n| n.sub(/^#{klass.table_name}\./, "")})
       else
         klass.disallow_raw_sql!(column_names)
+        columns = arel_columns(column_names)
         relation = spawn
-        relation.select_values = column_names
-        result = skip_query_cache_if_necessary { klass.connection.select_all(relation.arel, nil) }
-        result.cast_values(klass.attribute_types)
+        relation.select_values = columns
+        
+        result = skip_query_cache_if_necessary do
+          if where_clause.contradiction?
+            ActiveRecord::Result.new([], [])
+          else
+            klass.connection.select_all(relation.arel, nil)
+          end
+        end
+        type_cast_pluck_values(result, columns)
       end
     end
 

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