activerecord 6.0.0.beta2 → 6.0.2.rc1

data/lib/active_record/relation/where_clause.rb

@@ -70,7 +70,15 @@ module ActiveRecord
           predicates == other.predicates
       end
 
-      def invert
+      def invert(as = :nand)
+        if predicates.size == 1
+          inverted_predicates = [ invert_predicate(predicates.first) ]
+        elsif as == :nor
+          inverted_predicates = predicates.map { |node| invert_predicate(node) }
+        else
+          inverted_predicates = [ Arel::Nodes::Not.new(ast) ]
+        end
+
         WhereClause.new(inverted_predicates)
       end
 
@@ -115,10 +123,6 @@ module ActiveRecord
           node.respond_to?(:operator) && node.operator == :==
         end
 
-        def inverted_predicates
-          predicates.map { |node| invert_predicate(node) }
-        end
-
         def invert_predicate(node)
           case node
           when NilClass

data/lib/active_record/sanitization.rb

@@ -61,8 +61,9 @@ module ActiveRecord
       #   # => "id ASC"
       def sanitize_sql_for_order(condition)
         if condition.is_a?(Array) && condition.first.to_s.include?("?")
-          disallow_raw_sql!([condition.first],
-            permit: AttributeMethods::ClassMethods::COLUMN_NAME_WITH_ORDER
+          disallow_raw_sql!(
+            [condition.first],
+            permit: connection.column_name_with_order_matcher
           )
 
           # Ensure we aren't dealing with a subclass of String that might
@@ -133,6 +134,33 @@ module ActiveRecord
         end
       end
 
+      def disallow_raw_sql!(args, permit: connection.column_name_matcher) # :nodoc:
+        unexpected = nil
+        args.each do |arg|
+          next if arg.is_a?(Symbol) || Arel.arel_node?(arg) || permit.match?(arg.to_s)
+          (unexpected ||= []) << arg
+        end
+
+        return unless unexpected
+
+        if allow_unsafe_raw_sql == :deprecated
+          ActiveSupport::Deprecation.warn(
+            "Dangerous query method (method whose arguments are used as raw " \
+            "SQL) called with non-attribute argument(s): " \
+            "#{unexpected.map(&:inspect).join(", ")}. Non-attribute " \
+            "arguments will be disallowed in Rails 6.1. This method should " \
+            "not be called with user-provided values, such as request " \
+            "parameters or model attributes. Known-safe values can be passed " \
+            "by wrapping them in Arel.sql()."
+          )
+        else
+          raise(ActiveRecord::UnknownAttributeReference,
+            "Query method called with non-attribute argument(s): " +
+            unexpected.map(&:inspect).join(", ")
+          )
+        end
+      end
+
       private
         def replace_bind_variables(statement, values)
           raise_if_bind_arity_mismatch(statement, statement.count("?"), values.size)
@@ -165,10 +193,11 @@ module ActiveRecord
 
         def quote_bound_value(value, c = connection)
           if value.respond_to?(:map) && !value.acts_like?(:string)
-            if value.respond_to?(:empty?) && value.empty?
+            quoted = value.map { |v| c.quote(v) }
+            if quoted.empty?
               c.quote(nil)
             else
-              value.map { |v| c.quote(v) }.join(",")
+              quoted.join(",")
             end
           else
             c.quote(value)

data/lib/active_record/schema.rb

@@ -50,7 +50,7 @@ module ActiveRecord
       instance_eval(&block)
 
       if info[:version].present?
-        ActiveRecord::SchemaMigration.create_table
+        connection.schema_migration.create_table
         connection.assume_migrated_upto_version(info[:version])
       end
 

data/lib/active_record/schema_dumper.rb

@@ -47,6 +47,7 @@ module ActiveRecord
     end
 
     private
+      attr_accessor :table_name
 
       def initialize(connection, options = {})
         @connection = connection
@@ -110,6 +111,8 @@ HEADER
       def table(table, stream)
         columns = @connection.columns(table)
         begin
+          self.table_name = table
+
           tbl = StringIO.new
 
           # first dump primary key column
@@ -143,7 +146,11 @@ HEADER
             raise StandardError, "Unknown type '#{column.sql_type}' for column '#{column.name}'" unless @connection.valid_type?(column.type)
             next if column.name == pk
             type, colspec = column_spec(column)
-            tbl.print "    t.#{type} #{column.name.inspect}"
+            if type.is_a?(Symbol)
+              tbl.print "    t.#{type} #{column.name.inspect}"
+            else
+              tbl.print "    t.column #{column.name.inspect}, #{type.inspect}"
+            end
             tbl.print ", #{format_colspec(colspec)}" if colspec.present?
             tbl.puts
           end
@@ -159,6 +166,8 @@ HEADER
           stream.puts "# Could not dump table #{table.inspect} because of following #{e.class}"
           stream.puts "#   #{e.message}"
           stream.puts
+        ensure
+          self.table_name = nil
         end
       end
 

data/lib/active_record/schema_migration.rb

@@ -19,7 +19,7 @@ module ActiveRecord
       end
 
       def table_name
-        "#{table_name_prefix}#{ActiveRecord::Base.schema_migrations_table_name}#{table_name_suffix}"
+        "#{table_name_prefix}#{schema_migrations_table_name}#{table_name_suffix}"
       end
 
       def table_exists?

data/lib/active_record/scoping/default.rb

@@ -86,8 +86,8 @@ module ActiveRecord
           #       # Should return a scope, you can call 'super' here etc.
           #     end
           #   end
-          def default_scope(scope = nil) # :doc:
-            scope = Proc.new if block_given?
+          def default_scope(scope = nil, &block) # :doc:
+            scope = block if block_given?
 
             if scope.is_a?(Relation) || !scope.respond_to?(:call)
               raise ArgumentError,
@@ -100,7 +100,7 @@ module ActiveRecord
             self.default_scopes += [scope]
           end
 
-          def build_default_scope(base_rel = nil)
+          def build_default_scope(relation = relation())
             return if abstract_class?
 
             if default_scope_override.nil?
@@ -111,15 +111,14 @@ module ActiveRecord
               # The user has defined their own default scope method, so call that
               evaluate_default_scope do
                 if scope = default_scope
-                  (base_rel ||= relation).merge!(scope)
+                  relation.merge!(scope)
                 end
               end
             elsif default_scopes.any?
-              base_rel ||= relation
               evaluate_default_scope do
-                default_scopes.inject(base_rel) do |default_scope, scope|
+                default_scopes.inject(relation) do |default_scope, scope|
                   scope = scope.respond_to?(:to_proc) ? scope : scope.method(:call)
-                  default_scope.merge!(base_rel.instance_exec(&scope))
+                  default_scope.instance_exec(&scope) || default_scope
                 end
               end
             end

data/lib/active_record/scoping/named.rb

@@ -31,7 +31,8 @@ module ActiveRecord
               ActiveSupport::Deprecation.warn(<<~MSG.squish)
                 Class level methods will no longer inherit scoping from `#{scope._deprecated_scope_source}`
                 in Rails 6.1. To continue using the scoped relation, pass it into the block directly.
-                To instead access the full set of models, as Rails 6.1 will, use `#{name}.unscoped`.
+                To instead access the full set of models, as Rails 6.1 will, use `#{name}.unscoped`,
+                or `#{name}.default_scoped` if a model has default scopes.
               MSG
             end
 
@@ -58,7 +59,7 @@ module ActiveRecord
         end
 
         def default_extensions # :nodoc:
-          if scope = current_scope || build_default_scope
+          if scope = scope_for_association || build_default_scope
             scope.extensions
           else
             []

data/lib/active_record/statement_cache.rb

@@ -113,8 +113,8 @@ module ActiveRecord
       end
     end
 
-    def self.create(connection, block = Proc.new)
-      relation = block.call Params.new
+    def self.create(connection, callable = nil, &block)
+      relation = (callable || block).call Params.new
       query_builder, binds = connection.cacheable_query(self, relation.arel)
       bind_map = BindMap.new(binds)
       new(query_builder, bind_map, relation.klass)

data/lib/active_record/store.rb

@@ -11,6 +11,12 @@ module ActiveRecord
   # of the model. This is very helpful for easily exposing store keys to a form or elsewhere that's
   # already built around just accessing attributes on the model.
   #
+  # Every accessor comes with dirty tracking methods (+key_changed?+, +key_was+ and +key_change+) and
+  # methods to access the changes made during the last save (+saved_change_to_key?+, +saved_change_to_key+ and
+  # +key_before_last_save+).
+  #
+  # NOTE: There is no +key_will_change!+ method for accessors, use +store_will_change!+ instead.
+  #
   # Make sure that you declare the database column used for the serialized store as a text, so there's
   # plenty of room.
   #
@@ -49,6 +55,12 @@ module ActiveRecord
   #   u.settings[:country]  # => 'Denmark'
   #   u.settings['country'] # => 'Denmark'
   #
+  #   # Dirty tracking
+  #   u.color = 'green'
+  #   u.color_changed? # => true
+  #   u.color_was # => 'black'
+  #   u.color_change # => ['black', 'red']
+  #
   #   # Add additional accessors to an existing store through store_accessor
   #   class SuperUser < User
   #     store_accessor :settings, :privileges, :servants
@@ -127,6 +139,42 @@ module ActiveRecord
             define_method(accessor_key) do
               read_store_attribute(store_attribute, key)
             end
+
+            define_method("#{accessor_key}_changed?") do
+              return false unless attribute_changed?(store_attribute)
+              prev_store, new_store = changes[store_attribute]
+              prev_store&.dig(key) != new_store&.dig(key)
+            end
+
+            define_method("#{accessor_key}_change") do
+              return unless attribute_changed?(store_attribute)
+              prev_store, new_store = changes[store_attribute]
+              [prev_store&.dig(key), new_store&.dig(key)]
+            end
+
+            define_method("#{accessor_key}_was") do
+              return unless attribute_changed?(store_attribute)
+              prev_store, _new_store = changes[store_attribute]
+              prev_store&.dig(key)
+            end
+
+            define_method("saved_change_to_#{accessor_key}?") do
+              return false unless saved_change_to_attribute?(store_attribute)
+              prev_store, new_store = saved_change_to_attribute(store_attribute)
+              prev_store&.dig(key) != new_store&.dig(key)
+            end
+
+            define_method("saved_change_to_#{accessor_key}") do
+              return unless saved_change_to_attribute?(store_attribute)
+              prev_store, new_store = saved_change_to_attribute(store_attribute)
+              [prev_store&.dig(key), new_store&.dig(key)]
+            end
+
+            define_method("#{accessor_key}_before_last_save") do
+              return unless saved_change_to_attribute?(store_attribute)
+              prev_store, _new_store = saved_change_to_attribute(store_attribute)
+              prev_store&.dig(key)
+            end
           end
         end
 

data/lib/active_record/table_metadata.rb

@@ -4,17 +4,18 @@ module ActiveRecord
   class TableMetadata # :nodoc:
     delegate :foreign_type, :foreign_key, :join_primary_key, :join_foreign_key, to: :association, prefix: true
 
-    def initialize(klass, arel_table, association = nil)
+    def initialize(klass, arel_table, association = nil, types = klass)
       @klass = klass
+      @types = types
       @arel_table = arel_table
       @association = association
     end
 
     def resolve_column_aliases(hash)
       new_hash = hash.dup
-      hash.each do |key, _|
-        if (key.is_a?(Symbol)) && klass.attribute_alias?(key)
-          new_hash[klass.attribute_alias(key)] = new_hash.delete(key)
+      hash.each_key do |key|
+        if key.is_a?(Symbol) && new_key = klass.attribute_aliases[key.to_s]
+          new_hash[new_key] = new_hash.delete(key)
         end
       end
       new_hash
@@ -29,11 +30,7 @@ module ActiveRecord
     end
 
     def type(column_name)
-      if klass
-        klass.type_for_attribute(column_name)
-      else
-        Type.default_value
-      end
+      types.type_for_attribute(column_name)
     end
 
     def has_column?(column_name)
@@ -52,13 +49,12 @@ module ActiveRecord
       elsif association && !association.polymorphic?
         association_klass = association.klass
         arel_table = association_klass.arel_table.alias(table_name)
+        TableMetadata.new(association_klass, arel_table, association)
       else
         type_caster = TypeCaster::Connection.new(klass, table_name)
-        association_klass = nil
         arel_table = Arel::Table.new(table_name, type_caster: type_caster)
+        TableMetadata.new(nil, arel_table, association, type_caster)
       end
-
-      TableMetadata.new(association_klass, arel_table, association)
     end
 
     def polymorphic_association?
@@ -74,6 +70,6 @@ module ActiveRecord
     end
 
     private
-      attr_reader :klass, :arel_table, :association
+      attr_reader :klass, :types, :arel_table, :association
   end
 end

data/lib/active_record/tasks/database_tasks.rb

@@ -141,8 +141,21 @@ module ActiveRecord
         end
       end
 
-      def for_each
-        databases = Rails.application.config.database_configuration
+      def setup_initial_database_yaml
+        return {} unless defined?(Rails)
+
+        begin
+          Rails.application.config.load_database_yaml
+        rescue
+          $stderr.puts "Rails couldn't infer whether you are using multiple databases from your database.yml and can't generate the tasks for the non-primary databases. If you'd like to use this feature, please simplify your ERB."
+
+          {}
+        end
+      end
+
+      def for_each(databases)
+        return {} unless defined?(Rails)
+
         database_configs = ActiveRecord::DatabaseConfigurations.new(databases).configs_for(env_name: Rails.env)
 
         # if this is a single database application we don't want tasks for each primary database
@@ -153,8 +166,22 @@ module ActiveRecord
         end
       end
 
-      def create_current(environment = env)
-        each_current_configuration(environment) { |configuration|
+      def raise_for_multi_db(environment = env, command:)
+        db_configs = ActiveRecord::Base.configurations.configs_for(env_name: environment)
+
+        if db_configs.count > 1
+          dbs_list = []
+
+          db_configs.each do |db|
+            dbs_list << "#{command}:#{db.spec_name}"
+          end
+
+          raise "You're using a multiple database application. To use `#{command}` you must run the namespaced task with a VERSION. Available tasks are #{dbs_list.to_sentence}."
+        end
+      end
+
+      def create_current(environment = env, spec_name = nil)
+        each_current_configuration(environment, spec_name) { |configuration|
           create configuration
         }
         ActiveRecord::Base.establish_connection(environment.to_sym)
@@ -182,6 +209,26 @@ module ActiveRecord
         }
       end
 
+      def truncate_tables(configuration)
+        ActiveRecord::Base.connected_to(database: { truncation: configuration }) do
+          conn = ActiveRecord::Base.connection
+          table_names = conn.tables
+          table_names -= [
+            conn.schema_migration.table_name,
+            InternalMetadata.table_name
+          ]
+
+          ActiveRecord::Base.connection.truncate_tables(*table_names)
+        end
+      end
+      private :truncate_tables
+
+      def truncate_all(environment = env)
+        ActiveRecord::Base.configurations.configs_for(env_name: environment).each do |db_config|
+          truncate_tables db_config.config
+        end
+      end
+
       def migrate
         check_target_version
 
@@ -198,7 +245,7 @@ module ActiveRecord
       end
 
       def migrate_status
-        unless ActiveRecord::SchemaMigration.table_exists?
+        unless ActiveRecord::Base.connection.schema_migration.table_exists?
           Kernel.abort "Schema migrations table does not exist yet."
         end
 
@@ -286,10 +333,60 @@ module ActiveRecord
         end
         ActiveRecord::InternalMetadata.create_table
         ActiveRecord::InternalMetadata[:environment] = environment
+        ActiveRecord::InternalMetadata[:schema_sha1] = schema_sha1(file)
       ensure
         Migration.verbose = verbose_was
       end
 
+      def schema_up_to_date?(configuration, format = ActiveRecord::Base.schema_format, file = nil, environment = env, spec_name = "primary")
+        file ||= dump_filename(spec_name, format)
+
+        return true unless File.exist?(file)
+
+        ActiveRecord::Base.establish_connection(configuration)
+        return false unless ActiveRecord::InternalMetadata.table_exists?
+        ActiveRecord::InternalMetadata[:schema_sha1] == schema_sha1(file)
+      end
+
+      def reconstruct_from_schema(configuration, format = ActiveRecord::Base.schema_format, file = nil, environment = env, spec_name = "primary") # :nodoc:
+        file ||= dump_filename(spec_name, format)
+
+        check_schema_file(file)
+
+        ActiveRecord::Base.establish_connection(configuration)
+
+        if schema_up_to_date?(configuration, format, file, environment, spec_name)
+          truncate_tables(configuration)
+        else
+          purge(configuration)
+          load_schema(configuration, format, file, environment, spec_name)
+        end
+      rescue ActiveRecord::NoDatabaseError
+        create(configuration)
+        load_schema(configuration, format, file, environment, spec_name)
+      end
+
+      def dump_schema(configuration, format = ActiveRecord::Base.schema_format, spec_name = "primary") # :nodoc:
+        require "active_record/schema_dumper"
+        filename = dump_filename(spec_name, format)
+        connection = ActiveRecord::Base.connection
+
+        case format
+        when :ruby
+          File.open(filename, "w:utf-8") do |file|
+            ActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection, file)
+          end
+        when :sql
+          structure_dump(configuration, filename)
+          if connection.schema_migration.table_exists?
+            File.open(filename, "a") do |f|
+              f.puts connection.dump_schema_information
+              f.print "\n"
+            end
+          end
+        end
+      end
+
       def schema_file(format = ActiveRecord::Base.schema_format)
         File.join(db_dir, schema_file_type(format))
       end
@@ -371,12 +468,14 @@ module ActiveRecord
           task.is_a?(String) ? task.constantize : task
         end
 
-        def each_current_configuration(environment)
+        def each_current_configuration(environment, spec_name = nil)
           environments = [environment]
           environments << "test" if environment == "development"
 
           environments.each do |env|
             ActiveRecord::Base.configurations.configs_for(env_name: env).each do |db_config|
+              next if spec_name && spec_name != db_config.spec_name
+
               yield db_config.config, db_config.spec_name, env
             end
           end
@@ -398,6 +497,10 @@ module ActiveRecord
         def local_database?(configuration)
           configuration["host"].blank? || LOCAL_HOSTS.include?(configuration["host"])
         end
+
+        def schema_sha1(file)
+          Digest::SHA1.hexdigest(File.read(file))
+        end
     end
   end
 end