activerecord 4.2.11.3 → 5.0.0

data/lib/active_record/tasks/database_tasks.rb

@@ -5,7 +5,7 @@ module ActiveRecord
     class DatabaseAlreadyExists < StandardError; end # :nodoc:
     class DatabaseNotSupported < StandardError; end # :nodoc:
 
-    # <tt>ActiveRecord::Tasks::DatabaseTasks</tt> is a utility class, which encapsulates
+    # ActiveRecord::Tasks::DatabaseTasks is a utility class, which encapsulates
     # logic behind common tasks used to manage database and migrations.
     #
     # The tasks defined here are used with Rake tasks provided by Active Record.
@@ -18,15 +18,15 @@ module ActiveRecord
     #
     # The possible config values are:
     #
-    #   * +env+: current environment (like Rails.env).
-    #   * +database_configuration+: configuration of your databases (as in +config/database.yml+).
-    #   * +db_dir+: your +db+ directory.
-    #   * +fixtures_path+: a path to fixtures directory.
-    #   * +migrations_paths+: a list of paths to directories with migrations.
-    #   * +seed_loader+: an object which will load seeds, it needs to respond to the +load_seed+ method.
-    #   * +root+: a path to the root of the application.
+    # * +env+: current environment (like Rails.env).
+    # * +database_configuration+: configuration of your databases (as in +config/database.yml+).
+    # * +db_dir+: your +db+ directory.
+    # * +fixtures_path+: a path to fixtures directory.
+    # * +migrations_paths+: a list of paths to directories with migrations.
+    # * +seed_loader+: an object which will load seeds, it needs to respond to the +load_seed+ method.
+    # * +root+: a path to the root of the application.
     #
-    # Example usage of +DatabaseTasks+ outside Rails could look as such:
+    # Example usage of DatabaseTasks outside Rails could look as such:
     #
     #   include ActiveRecord::Tasks
     #   DatabaseTasks.database_configuration = YAML.load_file('my_database_config.yml')
@@ -42,6 +42,22 @@ module ActiveRecord
 
       LOCAL_HOSTS    = ['127.0.0.1', 'localhost']
 
+      def check_protected_environments!
+        unless ENV['DISABLE_DATABASE_ENVIRONMENT_CHECK']
+          current = ActiveRecord::Migrator.current_environment
+          stored  = ActiveRecord::Migrator.last_stored_environment
+
+          if ActiveRecord::Migrator.protected_environment?
+            raise ActiveRecord::ProtectedEnvironmentError.new(stored)
+          end
+
+          if stored && stored != current
+            raise ActiveRecord::EnvironmentMismatchError.new(current: current, stored: stored)
+          end
+        end
+      rescue ActiveRecord::NoDatabaseError
+      end
+
       def register_task(pattern, task)
         @tasks ||= {}
         @tasks[pattern] = task
@@ -91,15 +107,21 @@ module ActiveRecord
       def create(*arguments)
         configuration = arguments.first
         class_for_adapter(configuration['adapter']).new(*arguments).create
+        $stdout.puts "Created database '#{configuration['database']}'"
       rescue DatabaseAlreadyExists
-        $stderr.puts "#{configuration['database']} already exists"
+        $stderr.puts "Database '#{configuration['database']}' already exists"
       rescue Exception => error
-        $stderr.puts error, *(error.backtrace)
+        $stderr.puts error
         $stderr.puts "Couldn't create database for #{configuration.inspect}"
+        raise
       end
 
       def create_all
+        old_pool = ActiveRecord::Base.connection_handler.retrieve_connection_pool(ActiveRecord::Base.connection_specification_name)
         each_local_configuration { |configuration| create configuration }
+        if old_pool
+          ActiveRecord::Base.connection_handler.establish_connection(old_pool.spec)
+        end
       end
 
       def create_current(environment = env)
@@ -112,11 +134,13 @@ module ActiveRecord
       def drop(*arguments)
         configuration = arguments.first
         class_for_adapter(configuration['adapter']).new(*arguments).drop
+        $stdout.puts "Dropped database '#{configuration['database']}'"
       rescue ActiveRecord::NoDatabaseError
         $stderr.puts "Database '#{configuration['database']}' does not exist"
       rescue Exception => error
-        $stderr.puts error, *(error.backtrace)
-        $stderr.puts "Couldn't drop #{configuration['database']}"
+        $stderr.puts error
+        $stderr.puts "Couldn't drop database '#{configuration['database']}'"
+        raise
       end
 
       def drop_all
@@ -130,8 +154,6 @@ module ActiveRecord
       end
 
       def migrate
-        raise "Empty VERSION provided" if ENV["VERSION"] && ENV["VERSION"].empty?
-
         verbose = ENV["VERBOSE"] ? ENV["VERBOSE"] == "true" : true
         version = ENV["VERSION"] ? ENV["VERSION"].to_i : nil
         scope   = ENV['SCOPE']
@@ -191,27 +213,7 @@ module ActiveRecord
         class_for_adapter(configuration['adapter']).new(*arguments).structure_load(filename)
       end
 
-      def load_schema(format = ActiveRecord::Base.schema_format, file = nil)
-        ActiveSupport::Deprecation.warn(<<-MSG.squish)
-          This method will act on a specific connection in the future.
-          To act on the current connection, use `load_schema_current` instead.
-        MSG
-
-        load_schema_current(format, file)
-      end
-
-      def schema_file(format = ActiveRecord::Base.schema_format)
-        case format
-        when :ruby
-          File.join(db_dir, "schema.rb")
-        when :sql
-          File.join(db_dir, "structure.sql")
-        end
-      end
-
-      # This method is the successor of +load_schema+. We should rename it
-      # after +load_schema+ went through a deprecation cycle. (Rails > 4.2)
-      def load_schema_for(configuration, format = ActiveRecord::Base.schema_format, file = nil) # :nodoc:
+      def load_schema(configuration, format = ActiveRecord::Base.schema_format, file = nil) # :nodoc:
         file ||= schema_file(format)
 
         case format
@@ -225,24 +227,37 @@ module ActiveRecord
         else
           raise ArgumentError, "unknown format #{format.inspect}"
         end
+        ActiveRecord::InternalMetadata.create_table
+        ActiveRecord::InternalMetadata[:environment] = ActiveRecord::Migrator.current_environment
       end
 
-      def load_schema_current_if_exists(format = ActiveRecord::Base.schema_format, file = nil, environment = env)
-        if File.exist?(file || schema_file(format))
-          load_schema_current(format, file, environment)
+      def load_schema_for(*args)
+        ActiveSupport::Deprecation.warn(<<-MSG.squish)
+          This method was renamed to `#load_schema` and will be removed in the future.
+          Use `#load_schema` instead.
+        MSG
+        load_schema(*args)
+      end
+
+      def schema_file(format = ActiveRecord::Base.schema_format)
+        case format
+        when :ruby
+          File.join(db_dir, "schema.rb")
+        when :sql
+          File.join(db_dir, "structure.sql")
         end
       end
 
       def load_schema_current(format = ActiveRecord::Base.schema_format, file = nil, environment = env)
         each_current_configuration(environment) { |configuration|
-          load_schema_for configuration, format, file
+          load_schema configuration, format, file
         }
         ActiveRecord::Base.establish_connection(environment.to_sym)
       end
 
       def check_schema_file(filename)
         unless File.exist?(filename)
-          message = %{#{filename} doesn't exist yet. Run `rake db:migrate` to create it, then try again.}
+          message = %{#{filename} doesn't exist yet. Run `rails db:migrate` to create it, then try again.}
           message << %{ If you do not intend to use a database, you should instead alter #{Rails.root}/config/application.rb to limit the frameworks that will be loaded.} if defined?(::Rails)
           Kernel.abort message
         end
@@ -270,8 +285,7 @@ module ActiveRecord
 
       def each_current_configuration(environment)
         environments = [environment]
-        # add test environment only if no RAILS_ENV was specified.
-        environments << 'test' if environment == 'development' && ENV['RAILS_ENV'].nil?
+        environments << 'test' if environment == 'development'
 
         configurations = ActiveRecord::Base.configurations.values_at(*environments)
         configurations.compact.each do |configuration|

data/lib/active_record/tasks/mysql_database_tasks.rb

@@ -1,8 +1,6 @@
 module ActiveRecord
   module Tasks # :nodoc:
     class MySQLDatabaseTasks # :nodoc:
-      DEFAULT_CHARSET     = ENV['CHARSET']   || 'utf8'
-      DEFAULT_COLLATION   = ENV['COLLATION'] || 'utf8_unicode_ci'
       ACCESS_DENIED_ERROR = 1045
 
       delegate :connection, :establish_connection, to: ActiveRecord::Base
@@ -23,7 +21,7 @@ module ActiveRecord
         end
       rescue error_class => error
         if error.respond_to?(:errno) && error.errno == ACCESS_DENIED_ERROR
-          $stdout.print error.error
+          $stdout.print error.message
           establish_connection root_configuration_without_database
           connection.create_database configuration['database'], creation_options
           if configuration['username'] != 'root'
@@ -59,6 +57,7 @@ module ActiveRecord
         args = prepare_command_options
         args.concat(["--result-file", "#{filename}"])
         args.concat(["--no-data"])
+        args.concat(["--routines"])
         args.concat(["#{configuration['database']}"])
 
         run_cmd('mysqldump', args, 'dumping')
@@ -86,12 +85,6 @@ module ActiveRecord
         Hash.new.tap do |options|
           options[:charset]     = configuration['encoding']   if configuration.include? 'encoding'
           options[:collation]   = configuration['collation']  if configuration.include? 'collation'
-
-          # Set default charset only when collation isn't set.
-          options[:charset]   ||= DEFAULT_CHARSET unless options[:collation]
-
-          # Set default collation only when charset is also default.
-          options[:collation] ||= DEFAULT_COLLATION if options[:charset] == DEFAULT_CHARSET
         end
       end
 
@@ -101,8 +94,6 @@ module ActiveRecord
           ArJdbcMySQL::Error
         elsif defined?(Mysql2)
           Mysql2::Error
-        elsif defined?(Mysql)
-          Mysql::Error
         else
           StandardError
         end
@@ -129,7 +120,7 @@ IDENTIFIED BY '#{configuration['password']}' WITH GRANT OPTION;
       end
 
       def prepare_command_options
-        {
+        args = {
           'host'      => '--host',
           'port'      => '--port',
           'socket'    => '--socket',
@@ -142,6 +133,8 @@ IDENTIFIED BY '#{configuration['password']}' WITH GRANT OPTION;
           'sslcipher' => '--ssl-cipher',
           'sslkey'    => '--ssl-key'
         }.map { |opt, arg| "#{arg}=#{configuration[opt]}" if configuration[opt] }.compact
+
+        args
       end
 
       def run_cmd(cmd, args, action)
@@ -149,8 +142,7 @@ IDENTIFIED BY '#{configuration['password']}' WITH GRANT OPTION;
       end
 
       def run_cmd_error(cmd, args, action)
-        msg = "failed to execute:\n"
-        msg << "#{cmd}"
+        msg = "failed to execute: `#{cmd}`\n"
         msg << "Please check the output above for any errors and make sure that `#{cmd}` is installed in your PATH and has proper permissions.\n\n"
         msg
       end

data/lib/active_record/tasks/postgresql_database_tasks.rb

@@ -44,8 +44,17 @@ module ActiveRecord
 
       def structure_dump(filename)
         set_psql_env
+
+        search_path = case ActiveRecord::Base.dump_schemas
+        when :schema_search_path
+          configuration['schema_search_path']
+        when :all
+          nil
+        when String
+          ActiveRecord::Base.dump_schemas
+        end
+
         args = ['-s', '-x', '-O', '-f', filename]
-        search_path = configuration['schema_search_path']
         unless search_path.blank?
           args += search_path.split(',').map do |part|
             "--schema=#{part.strip}"
@@ -59,7 +68,7 @@ module ActiveRecord
       def structure_load(filename)
         set_psql_env
         args = [ '-q', '-f', filename, configuration['database'] ]
-        run_cmd('psql', args, 'loading')
+        run_cmd('psql', args, 'loading' )
       end
 
       private

data/lib/active_record/tasks/sqlite_database_tasks.rb

@@ -19,11 +19,15 @@ module ActiveRecord
         path = Pathname.new configuration['database']
         file = path.absolute? ? path.to_s : File.join(root, path)
 
-        FileUtils.rm(file) if File.exist?(file)
+        FileUtils.rm(file)
+      rescue Errno::ENOENT => error
+        raise NoDatabaseError.new(error.message, error)
       end
 
       def purge
         drop
+      rescue NoDatabaseError
+      ensure
         create
       end
 

data/lib/active_record/timestamp.rb

@@ -1,5 +1,5 @@
 module ActiveRecord
-  # = Active Record Timestamp
+  # = Active Record \Timestamp
   #
   # Active Record automatically timestamps create and update operations if the
   # table has fields named <tt>created_at/created_on</tt> or
@@ -15,14 +15,25 @@ module ActiveRecord
   #
   # == Time Zone aware attributes
   #
-  # By default, ActiveRecord::Base keeps all the datetime columns time zone aware by executing following code.
+  # Active Record keeps all the <tt>datetime</tt> and <tt>time</tt> columns
+  # timezone aware. By default, these values are stored in the database as UTC
+  # and converted back to the current <tt>Time.zone</tt> when pulled from the database.
   #
-  #   config.active_record.time_zone_aware_attributes = true
+  # This feature can be turned off completely by setting:
   #
-  # This feature can easily be turned off by assigning value <tt>false</tt> .
+  #   config.active_record.time_zone_aware_attributes = false
   #
-  # If your attributes are time zone aware and you desire to skip time zone conversion to the current Time.zone
-  # when reading certain attributes then you can do following:
+  # You can also specify that only <tt>datetime</tt> columns should be time-zone
+  # aware (while <tt>time</tt> should not) by setting:
+  #
+  #   ActiveRecord::Base.time_zone_aware_types = [:datetime]
+  #
+  # You can also add database specific timezone aware types. For example, for PostgreSQL:
+  #
+  #   ActiveRecord::Base.time_zone_aware_types += [:tsrange, :tstzrange]
+  #
+  # Finally, you can indicate specific attributes of a model for which time zone
+  # conversion should not applied, for instance by setting:
   #
   #   class Topic < ActiveRecord::Base
   #     self.skip_time_zone_conversion_for_attributes = [:written_on]
@@ -57,8 +68,8 @@ module ActiveRecord
       super
     end
 
-    def _update_record(*args)
-      if should_record_timestamps?
+    def _update_record(*args, touch: true, **options)
+      if touch && should_record_timestamps?
         current_time = current_time_from_proper_timezone
 
         timestamp_attributes_for_update_in_model.each do |column|
@@ -67,7 +78,7 @@ module ActiveRecord
           write_attribute(column, current_time)
         end
       end
-      super
+      super(*args)
     end
 
     def should_record_timestamps?

data/lib/active_record/touch_later.rb

@@ -0,0 +1,58 @@
+module ActiveRecord
+  # = Active Record Touch Later
+  module TouchLater
+    extend ActiveSupport::Concern
+
+    included do
+      before_commit_without_transaction_enrollment :touch_deferred_attributes
+    end
+
+    def touch_later(*names) # :nodoc:
+      raise ActiveRecordError, "cannot touch on a new record object" unless persisted?
+
+      @_defer_touch_attrs ||= timestamp_attributes_for_update_in_model
+      @_defer_touch_attrs |= names
+      @_touch_time = current_time_from_proper_timezone
+
+      surreptitiously_touch @_defer_touch_attrs
+      self.class.connection.add_transaction_record self
+
+      # touch the parents as we are not calling the after_save callbacks
+      self.class.reflect_on_all_associations(:belongs_to).each do |r|
+        if touch = r.options[:touch]
+          ActiveRecord::Associations::Builder::BelongsTo.touch_record(self, r.foreign_key, r.name, touch, :touch_later)
+        end
+      end
+    end
+
+    def touch(*names, time: nil) # :nodoc:
+      if has_defer_touch_attrs?
+        names |= @_defer_touch_attrs
+      end
+      super(*names, time: time)
+    end
+
+    private
+
+      def surreptitiously_touch(attrs)
+        attrs.each { |attr| write_attribute attr, @_touch_time }
+        clear_attribute_changes attrs
+      end
+
+      def touch_deferred_attributes
+        if has_defer_touch_attrs? && persisted?
+          touch(*@_defer_touch_attrs, time: @_touch_time)
+          @_defer_touch_attrs, @_touch_time = nil, nil
+        end
+      end
+
+      def has_defer_touch_attrs?
+        defined?(@_defer_touch_attrs) && @_defer_touch_attrs.present?
+      end
+
+      def belongs_to_touch_method
+        :touch_later
+      end
+
+  end
+end