activerecord 5.1.4 → 5.1.5

data/lib/active_record/log_subscriber.rb

@@ -29,7 +29,7 @@ module ActiveRecord
       binds = nil
 
       unless (payload[:binds] || []).empty?
-        casted_params = type_casted_binds(payload[:binds], payload[:type_casted_binds])
+        casted_params = type_casted_binds(payload[:type_casted_binds])
         binds = "  " + payload[:binds].zip(casted_params).map { |attr, value|
           render_bind(attr, value)
         }.inspect
@@ -42,9 +42,8 @@ module ActiveRecord
     end
 
     private
-
-      def type_casted_binds(binds, casted_binds)
-        casted_binds || ActiveRecord::Base.connection.type_casted_binds(binds)
+      def type_casted_binds(casted_binds)
+        casted_binds.respond_to?(:call) ? casted_binds.call : casted_binds
       end
 
       def render_bind(attr, value)

data/lib/active_record/migration/compatibility.rb

@@ -42,11 +42,8 @@ module ActiveRecord
           end
 
           if block_given?
-            super(table_name, options) do |t|
-              class << t
-                prepend TableDefinition
-              end
-              yield t
+            super do |t|
+              yield compatible_table_definition(t)
             end
           else
             super
@@ -55,11 +52,20 @@ module ActiveRecord
 
         def change_table(table_name, options = {})
           if block_given?
-            super(table_name, options) do |t|
-              class << t
-                prepend TableDefinition
-              end
-              yield t
+            super do |t|
+              yield compatible_table_definition(t)
+            end
+          else
+            super
+          end
+        end
+
+        def create_join_table(table_1, table_2, column_options: {}, **options)
+          column_options.reverse_merge!(type: :integer)
+
+          if block_given?
+            super do |t|
+              yield compatible_table_definition(t)
             end
           else
             super
@@ -70,6 +76,14 @@ module ActiveRecord
           super(table_name, ref_name, type: :integer, **options)
         end
         alias :add_belongs_to :add_reference
+
+        private
+          def compatible_table_definition(t)
+            class << t
+              prepend TableDefinition
+            end
+            t
+          end
       end
 
       class V4_2 < V5_0
@@ -88,11 +102,8 @@ module ActiveRecord
 
         def create_table(table_name, options = {})
           if block_given?
-            super(table_name, options) do |t|
-              class << t
-                prepend TableDefinition
-              end
-              yield t
+            super do |t|
+              yield compatible_table_definition(t)
             end
           else
             super
@@ -101,11 +112,8 @@ module ActiveRecord
 
         def change_table(table_name, options = {})
           if block_given?
-            super(table_name, options) do |t|
-              class << t
-                prepend TableDefinition
-              end
-              yield t
+            super do |t|
+              yield compatible_table_definition(t)
             end
           else
             super
@@ -141,6 +149,12 @@ module ActiveRecord
         end
 
         private
+          def compatible_table_definition(t)
+            class << t
+              prepend TableDefinition
+            end
+            super
+          end
 
           def index_name_for_remove(table_name, options = {})
             index_name = index_name(table_name, options)

data/lib/active_record/model_schema.rb

@@ -84,19 +84,6 @@ module ActiveRecord
     #
     # Sets the name of the internal metadata table.
 
-    ##
-    # :singleton-method: protected_environments
-    # :call-seq: protected_environments
-    #
-    # The array of names of environments where destructive actions should be prohibited. By default,
-    # the value is <tt>["production"]</tt>.
-
-    ##
-    # :singleton-method: protected_environments=
-    # :call-seq: protected_environments=(environments)
-    #
-    # Sets an array of names of environments where destructive actions should be prohibited.
-
     ##
     # :singleton-method: pluralize_table_names
     # :call-seq: pluralize_table_names
@@ -113,20 +100,6 @@ module ActiveRecord
     # If true, the default table name for a Product class will be "products". If false, it would just be "product".
     # See table_name for the full rules on table/class naming. This is true, by default.
 
-    ##
-    # :singleton-method: ignored_columns
-    # :call-seq: ignored_columns
-    #
-    # The list of columns names the model should ignore. Ignored columns won't have attribute
-    # accessors defined, and won't be referenced in SQL queries.
-
-    ##
-    # :singleton-method: ignored_columns=
-    # :call-seq: ignored_columns=(columns)
-    #
-    # Sets the columns names the model should ignore. Ignored columns won't have attribute
-    # accessors defined, and won't be referenced in SQL queries.
-
     included do
       mattr_accessor :primary_key_prefix_type, instance_writer: false
 
@@ -142,16 +115,12 @@ module ActiveRecord
       class_attribute :internal_metadata_table_name, instance_accessor: false
       self.internal_metadata_table_name = "ar_internal_metadata"
 
-      class_attribute :protected_environments, instance_accessor: false
-      self.protected_environments = ["production"]
-
       class_attribute :pluralize_table_names, instance_writer: false
       self.pluralize_table_names = true
 
-      class_attribute :ignored_columns, instance_accessor: false
-      self.ignored_columns = [].freeze
-
+      self.protected_environments = ["production"]
       self.inheritance_column = "type"
+      self.ignored_columns = [].freeze
 
       delegate :type_for_attribute, to: :class
 
@@ -263,6 +232,21 @@ module ActiveRecord
         (parents.detect { |p| p.respond_to?(:table_name_suffix) } || self).table_name_suffix
       end
 
+      # The array of names of environments where destructive actions should be prohibited. By default,
+      # the value is <tt>["production"]</tt>.
+      def protected_environments
+        if defined?(@protected_environments)
+          @protected_environments
+        else
+          superclass.protected_environments
+        end
+      end
+
+      # Sets an array of names of environments where destructive actions should be prohibited.
+      def protected_environments=(environments)
+        @protected_environments = environments.map(&:to_s)
+      end
+
       # Defines the name of the table column which will store the class name on single-table
       # inheritance situations.
       #
@@ -282,6 +266,22 @@ module ActiveRecord
         @explicit_inheritance_column = true
       end
 
+      # The list of columns names the model should ignore. Ignored columns won't have attribute
+      # accessors defined, and won't be referenced in SQL queries.
+      def ignored_columns
+        if defined?(@ignored_columns)
+          @ignored_columns
+        else
+          superclass.ignored_columns
+        end
+      end
+
+      # Sets the columns names the model should ignore. Ignored columns won't have attribute
+      # accessors defined, and won't be referenced in SQL queries.
+      def ignored_columns=(columns)
+        @ignored_columns = columns.map(&:to_s)
+      end
+
       def sequence_name
         if base_class == self
           @sequence_name ||= reset_sequence_name

data/lib/active_record/persistence.rb

@@ -267,11 +267,7 @@ module ActiveRecord
       verify_readonly_attribute(name)
       public_send("#{name}=", value)
 
-      if has_changes_to_save?
-        save(validate: false)
-      else
-        true
-      end
+      save(validate: false)
     end
 
     # Updates the attributes of the model from the passed-in hash and saves the

data/lib/active_record/query_cache.rb

@@ -5,20 +5,20 @@ module ActiveRecord
       # Enable the query cache within the block if Active Record is configured.
       # If it's not, it will execute the given block.
       def cache(&block)
-        if connected?
-          connection.cache(&block)
-        else
+        if configurations.empty?
           yield
+        else
+          connection.cache(&block)
         end
       end
 
       # Disable the query cache within the block if Active Record is configured.
       # If it's not, it will execute the given block.
       def uncached(&block)
-        if connected?
-          connection.uncached(&block)
-        else
+        if configurations.empty?
           yield
+        else
+          connection.uncached(&block)
         end
       end
     end

data/lib/active_record/railties/databases.rake

@@ -311,7 +311,7 @@ db_namespace = namespace :db do
       begin
         should_reconnect = ActiveRecord::Base.connection_pool.active_connection?
         ActiveRecord::Schema.verbose = false
-        ActiveRecord::Tasks::DatabaseTasks.load_schema ActiveRecord::Base.configurations["test"], :ruby, ENV["SCHEMA"]
+        ActiveRecord::Tasks::DatabaseTasks.load_schema ActiveRecord::Base.configurations["test"], :ruby, ENV["SCHEMA"], "test"
       ensure
         if should_reconnect
           ActiveRecord::Base.establish_connection(ActiveRecord::Base.configurations[ActiveRecord::Tasks::DatabaseTasks.env])
@@ -321,7 +321,7 @@ db_namespace = namespace :db do
 
     # desc "Recreate the test database from an existent structure.sql file"
     task load_structure: %w(db:test:purge) do
-      ActiveRecord::Tasks::DatabaseTasks.load_schema ActiveRecord::Base.configurations["test"], :sql, ENV["SCHEMA"]
+      ActiveRecord::Tasks::DatabaseTasks.load_schema ActiveRecord::Base.configurations["test"], :sql, ENV["SCHEMA"], "test"
     end
 
     # desc "Empty the test database"

data/lib/active_record/reflection.rb

@@ -35,7 +35,8 @@ module ActiveRecord
 
     def self.add_reflection(ar, name, reflection)
       ar.clear_reflections_cache
-      ar._reflections = ar._reflections.merge(name.to_s => reflection)
+      name = name.to_s
+      ar._reflections = ar._reflections.except(name).merge!(name => reflection)
     end
 
     def self.add_aggregate_reflection(ar, name, reflection)
@@ -187,17 +188,24 @@ module ActiveRecord
       end
       deprecate :scope_chain
 
+      def join_scope(table)
+        predicate_builder = predicate_builder(table)
+        scope_chain_items = join_scopes(table, predicate_builder)
+        klass_scope       = klass_join_scope(table, predicate_builder)
+
+        scope_chain_items.inject(klass_scope || scope_chain_items.shift, &:merge!)
+      end
+
       def join_scopes(table, predicate_builder) # :nodoc:
         if scope
-          [ActiveRecord::Relation.create(klass, table, predicate_builder)
-            .instance_exec(&scope)]
+          [build_scope(table, predicate_builder).instance_exec(&scope)]
         else
           []
         end
       end
 
       def klass_join_scope(table, predicate_builder) # :nodoc:
-        relation = ActiveRecord::Relation.create(klass, table, predicate_builder)
+        relation = build_scope(table, predicate_builder)
         klass.scope_for_association(relation)
       end
 
@@ -279,7 +287,14 @@ module ActiveRecord
         JoinKeys.new(join_pk(association_klass), join_fk)
       end
 
+      def build_scope(table, predicate_builder = predicate_builder(table))
+        Relation.create(klass, table, predicate_builder)
+      end
+
       private
+        def predicate_builder(table)
+          PredicateBuilder.new(TableMetadata.new(klass, table))
+        end
 
         def join_pk(_)
           foreign_key
@@ -398,7 +413,6 @@ module ActiveRecord
 
       def initialize(name, scope, options, active_record)
         super
-        @automatic_inverse_of = nil
         @type         = options[:as] && (options[:foreign_type] || "#{options[:as]}_type")
         @foreign_type = options[:foreign_type] || "#{name}_type"
         @constructable = calculate_constructable(macro, options)
@@ -591,12 +605,14 @@ module ActiveRecord
         # If it cannot find a suitable inverse association name, it returns
         # +nil+.
         def inverse_name
-          options.fetch(:inverse_of) do
-            @automatic_inverse_of ||= automatic_inverse_of
+          unless defined?(@inverse_name)
+            @inverse_name = options.fetch(:inverse_of) { automatic_inverse_of }
           end
+
+          @inverse_name
         end
 
-        # returns either false or the inverse association name that it finds.
+        # returns either +nil+ or the inverse association name that it finds.
         def automatic_inverse_of
           if can_find_inverse_of_automatically?(self)
             inverse_name = ActiveSupport::Inflector.underscore(options[:as] || active_record.name.demodulize).to_sym
@@ -613,8 +629,6 @@ module ActiveRecord
               return inverse_name
             end
           end
-
-          false
         end
 
         # Checks if the inverse reflection that is returned from the

data/lib/active_record/relation/calculations.rb

@@ -111,7 +111,14 @@ module ActiveRecord
     def calculate(operation, column_name)
       if has_include?(column_name)
         relation = construct_relation_for_association_calculations
-        relation.distinct! if operation.to_s.downcase == "count"
+
+        if operation.to_s.downcase == "count" && !distinct_value
+          relation.distinct!
+          # PostgreSQL: ORDER BY expressions must appear in SELECT list when using DISTINCT
+          if (column_name == :all || column_name.nil?) && select_values.empty?
+            relation.order_values = []
+          end
+        end
 
         relation.calculate(operation, column_name)
       else
@@ -195,7 +202,7 @@ module ActiveRecord
         if operation == "count"
           column_name ||= select_for_count
           if column_name == :all
-            if distinct && !(has_limit_or_offset? && order_values.any?)
+            if distinct && (group_values.any? || select_values.empty? && order_values.empty?)
               column_name = primary_key
             end
           elsif column_name =~ /\s*DISTINCT[\s(]+/i
@@ -227,7 +234,7 @@ module ActiveRecord
       def execute_simple_calculation(operation, column_name, distinct) #:nodoc:
         column_alias = column_name
 
-        if operation == "count" && has_limit_or_offset?
+        if operation == "count" && (column_name == :all && distinct || has_limit_or_offset?)
           # Shortcut when limit is zero.
           return 0 if limit_value == 0
 
@@ -369,14 +376,12 @@ module ActiveRecord
       end
 
       def build_count_subquery(relation, column_name, distinct)
-        relation.select_values = [
-          if column_name == :all
-            distinct ? table[Arel.star] : Arel.sql("1")
-          else
-            column_alias = Arel.sql("count_column")
-            aggregate_column(column_name).as(column_alias)
-          end
-        ]
+        if column_name == :all
+          relation.select_values = [ Arel.sql(FinderMethods::ONE_AS_ONE) ] unless distinct
+        else
+          column_alias = Arel.sql("count_column")
+          relation.select_values = [ aggregate_column(column_name).as(column_alias) ]
+        end
 
         subquery = relation.arel.as(Arel.sql("subquery_for_count"))
         select_value = operation_over_aggregate_column(column_alias || Arel.star, "count", false)

data/lib/active_record/relation/finder_methods.rb

@@ -371,17 +371,7 @@ module ActiveRecord
         relation = select aliases.columns
         relation = apply_join_dependency(relation, join_dependency)
 
-        if block_given?
-          yield relation
-        else
-          if ActiveRecord::NullRelation === relation
-            []
-          else
-            arel = relation.arel
-            rows = connection.select_all(arel, "SQL", relation.bound_attributes)
-            join_dependency.instantiate(rows, aliases)
-          end
-        end
+        yield relation, join_dependency
       end
 
       def construct_relation_for_exists(relation, conditions)

data/lib/active_record/relation/query_methods.rb

@@ -1041,6 +1041,8 @@ module ActiveRecord
       def build_select(arel)
         if select_values.any?
           arel.project(*arel_columns(select_values.uniq))
+        elsif klass.ignored_columns.any?
+          arel.project(*klass.column_names.map { |field| arel_attribute(field) })
         else
           arel.project(@klass.arel_table[Arel.star])
         end
@@ -1177,21 +1179,24 @@ module ActiveRecord
       end
       alias having_clause_factory where_clause_factory
 
+      DEFAULT_VALUES = {
+        create_with: FROZEN_EMPTY_HASH,
+        readonly: false,
+        where: Relation::WhereClause.empty,
+        having: Relation::WhereClause.empty,
+        from: Relation::FromClause.empty
+      }
+
+      Relation::MULTI_VALUE_METHODS.each do |value|
+        DEFAULT_VALUES[value] ||= FROZEN_EMPTY_ARRAY
+      end
+
+      Relation::SINGLE_VALUE_METHODS.each do |value|
+        DEFAULT_VALUES[value] = nil if DEFAULT_VALUES[value].nil?
+      end
+
       def default_value_for(name)
-        case name
-        when :create_with
-          FROZEN_EMPTY_HASH
-        when :readonly
-          false
-        when :where, :having
-          Relation::WhereClause.empty
-        when :from
-          Relation::FromClause.empty
-        when *Relation::MULTI_VALUE_METHODS
-          FROZEN_EMPTY_ARRAY
-        when *Relation::SINGLE_VALUE_METHODS
-          nil
-        else
+        DEFAULT_VALUES.fetch(name) do
           raise ArgumentError, "unknown relation value #{name.inspect}"
         end
       end

data/lib/active_record/relation.rb

@@ -571,7 +571,7 @@ module ActiveRecord
                     relation = self
 
                     if eager_loading?
-                      find_with_associations { |rel| relation = rel }
+                      find_with_associations { |rel, _| relation = rel }
                     end
 
                     conn = klass.connection
@@ -664,7 +664,19 @@ module ActiveRecord
       end
 
       def exec_queries(&block)
-        @records = eager_loading? ? find_with_associations.freeze : @klass.find_by_sql(arel, bound_attributes, &block).freeze
+        @records =
+          if eager_loading?
+            find_with_associations do |relation, join_dependency|
+              if ActiveRecord::NullRelation === relation
+                []
+              else
+                rows = connection.select_all(relation.arel, "SQL", relation.bound_attributes)
+                join_dependency.instantiate(rows, &block)
+              end.freeze
+            end
+          else
+            klass.find_by_sql(arel, bound_attributes, &block).freeze
+          end
 
         preload = preload_values
         preload += includes_values unless eager_loading?

data/lib/active_record/tasks/database_tasks.rb

@@ -223,22 +223,22 @@ module ActiveRecord
         class_for_adapter(configuration["adapter"]).new(*arguments).structure_load(filename, structure_load_flags)
       end
 
-      def load_schema(configuration, format = ActiveRecord::Base.schema_format, file = nil) # :nodoc:
+      def load_schema(configuration, format = ActiveRecord::Base.schema_format, file = nil, environment = env) # :nodoc:
         file ||= schema_file(format)
 
+        check_schema_file(file)
+        ActiveRecord::Base.establish_connection(configuration)
+
         case format
         when :ruby
-          check_schema_file(file)
-          ActiveRecord::Base.establish_connection(configuration)
           load(file)
         when :sql
-          check_schema_file(file)
           structure_load(configuration, file)
         else
           raise ArgumentError, "unknown format #{format.inspect}"
         end
         ActiveRecord::InternalMetadata.create_table
-        ActiveRecord::InternalMetadata[:environment] = ActiveRecord::Migrator.current_environment
+        ActiveRecord::InternalMetadata[:environment] = environment
       end
 
       def schema_file(format = ActiveRecord::Base.schema_format)
@@ -251,8 +251,8 @@ module ActiveRecord
       end
 
       def load_schema_current(format = ActiveRecord::Base.schema_format, file = nil, environment = env)
-        each_current_configuration(environment) { |configuration|
-          load_schema configuration, format, file
+        each_current_configuration(environment) { |configuration, configuration_environment|
+          load_schema configuration, format, file, configuration_environment
         }
         ActiveRecord::Base.establish_connection(environment.to_sym)
       end
@@ -299,9 +299,10 @@ module ActiveRecord
           environments = [environment]
           environments << "test" if environment == "development"
 
-          configurations = ActiveRecord::Base.configurations.values_at(*environments)
-          configurations.compact.each do |configuration|
-            yield configuration unless configuration["database"].blank?
+          ActiveRecord::Base.configurations.slice(*environments).each do |configuration_environment, configuration|
+            next unless configuration["database"]
+
+            yield configuration, configuration_environment
           end
         end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activerecord
 version: !ruby/object:Gem::Version
-  version: 5.1.4
+  version: 5.1.5
 platform: ruby
 authors:
 - David Heinemeier Hansson
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-09-08 00:00:00.000000000 Z
+date: 2018-02-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -16,28 +16,28 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 5.1.4
+        version: 5.1.5
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 5.1.4
+        version: 5.1.5
 - !ruby/object:Gem::Dependency
   name: activemodel
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 5.1.4
+        version: 5.1.5
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 5.1.4
+        version: 5.1.5
 - !ruby/object:Gem::Dependency
   name: arel
   requirement: !ruby/object:Gem::Requirement
@@ -319,7 +319,9 @@ files:
 homepage: http://rubyonrails.org
 licenses:
 - MIT
-metadata: {}
+metadata:
+  source_code_uri: https://github.com/rails/rails/tree/v5.1.5/activerecord
+  changelog_uri: https://github.com/rails/rails/blob/v5.1.5/activerecord/CHANGELOG.md
 post_install_message: 
 rdoc_options:
 - "--main"
@@ -338,7 +340,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.13
+rubygems_version: 2.7.3
 signing_key: 
 specification_version: 4
 summary: Object-relational mapper framework (part of Rails).