activerecord 5.0.7.2 → 5.1.0.beta1

data/lib/active_record/tasks/mysql_database_tasks.rb

@@ -11,10 +11,10 @@ module ActiveRecord
 
       def create
         establish_connection configuration_without_database
-        connection.create_database configuration['database'], creation_options
+        connection.create_database configuration["database"], creation_options
         establish_connection configuration
       rescue ActiveRecord::StatementInvalid => error
-        if /database exists/ === error.message
+        if error.message.include?("database exists")
           raise DatabaseAlreadyExists
         else
           raise
@@ -23,26 +23,26 @@ module ActiveRecord
         if error.respond_to?(:errno) && error.errno == ACCESS_DENIED_ERROR
           $stdout.print error.message
           establish_connection root_configuration_without_database
-          connection.create_database configuration['database'], creation_options
-          if configuration['username'] != 'root'
-            connection.execute grant_statement.gsub(/\s+/, ' ').strip
+          connection.create_database configuration["database"], creation_options
+          if configuration["username"] != "root"
+            connection.execute grant_statement.gsub(/\s+/, " ").strip
           end
           establish_connection configuration
         else
           $stderr.puts error.inspect
           $stderr.puts "Couldn't create database for #{configuration.inspect}, #{creation_options.inspect}"
-          $stderr.puts "(If you set the charset manually, make sure you have a matching collation)" if configuration['encoding']
+          $stderr.puts "(If you set the charset manually, make sure you have a matching collation)" if configuration["encoding"]
         end
       end
 
       def drop
         establish_connection configuration
-        connection.drop_database configuration['database']
+        connection.drop_database configuration["database"]
       end
 
       def purge
         establish_connection configuration
-        connection.recreate_database configuration['database'], creation_options
+        connection.recreate_database configuration["database"], creation_options
       end
 
       def charset
@@ -53,99 +53,102 @@ module ActiveRecord
         connection.collation
       end
 
-      def structure_dump(filename)
+      def structure_dump(filename, extra_flags)
         args = prepare_command_options
         args.concat(["--result-file", "#{filename}"])
         args.concat(["--no-data"])
         args.concat(["--routines"])
+        args.concat(["--skip-comments"])
+        args.concat(Array(extra_flags)) if extra_flags
         args.concat(["#{configuration['database']}"])
 
-        run_cmd('mysqldump', args, 'dumping')
+        run_cmd("mysqldump", args, "dumping")
       end
 
-      def structure_load(filename)
+      def structure_load(filename, extra_flags)
         args = prepare_command_options
-        args.concat(['--execute', %{SET FOREIGN_KEY_CHECKS = 0; SOURCE #{filename}; SET FOREIGN_KEY_CHECKS = 1}])
+        args.concat(["--execute", %{SET FOREIGN_KEY_CHECKS = 0; SOURCE #{filename}; SET FOREIGN_KEY_CHECKS = 1}])
         args.concat(["--database", "#{configuration['database']}"])
+        args.concat(Array(extra_flags)) if extra_flags
 
-        run_cmd('mysql', args, 'loading')
+        run_cmd("mysql", args, "loading")
       end
 
       private
 
-      def configuration
-        @configuration
-      end
+        def configuration
+          @configuration
+        end
 
-      def configuration_without_database
-        configuration.merge('database' => nil)
-      end
+        def configuration_without_database
+          configuration.merge("database" => nil)
+        end
 
-      def creation_options
-        Hash.new.tap do |options|
-          options[:charset]     = configuration['encoding']   if configuration.include? 'encoding'
-          options[:collation]   = configuration['collation']  if configuration.include? 'collation'
+        def creation_options
+          Hash.new.tap do |options|
+            options[:charset]     = configuration["encoding"]   if configuration.include? "encoding"
+            options[:collation]   = configuration["collation"]  if configuration.include? "collation"
+          end
         end
-      end
 
-      def error_class
-        if configuration['adapter'] =~ /jdbc/
-          require 'active_record/railties/jdbcmysql_error'
-          ArJdbcMySQL::Error
-        elsif defined?(Mysql2)
-          Mysql2::Error
-        else
-          StandardError
+        def error_class
+          if configuration["adapter"].include?("jdbc")
+            require "active_record/railties/jdbcmysql_error"
+            ArJdbcMySQL::Error
+          elsif defined?(Mysql2)
+            Mysql2::Error
+          else
+            StandardError
+          end
         end
-      end
 
-      def grant_statement
-        <<-SQL
+        def grant_statement
+          <<-SQL
 GRANT ALL PRIVILEGES ON #{configuration['database']}.*
   TO '#{configuration['username']}'@'localhost'
 IDENTIFIED BY '#{configuration['password']}' WITH GRANT OPTION;
-        SQL
-      end
+          SQL
+        end
 
-      def root_configuration_without_database
-        configuration_without_database.merge(
-          'username' => 'root',
-          'password' => root_password
-        )
-      end
+        def root_configuration_without_database
+          configuration_without_database.merge(
+            "username" => "root",
+            "password" => root_password
+          )
+        end
 
-      def root_password
-        $stdout.print "Please provide the root password for your MySQL installation\n>"
-        $stdin.gets.strip
-      end
+        def root_password
+          $stdout.print "Please provide the root password for your MySQL installation\n>"
+          $stdin.gets.strip
+        end
 
-      def prepare_command_options
-        args = {
-          'host'      => '--host',
-          'port'      => '--port',
-          'socket'    => '--socket',
-          'username'  => '--user',
-          'password'  => '--password',
-          'encoding'  => '--default-character-set',
-          'sslca'     => '--ssl-ca',
-          'sslcert'   => '--ssl-cert',
-          'sslcapath' => '--ssl-capath',
-          'sslcipher' => '--ssl-cipher',
-          'sslkey'    => '--ssl-key'
-        }.map { |opt, arg| "#{arg}=#{configuration[opt]}" if configuration[opt] }.compact
-
-        args
-      end
+        def prepare_command_options
+          args = {
+            "host"      => "--host",
+            "port"      => "--port",
+            "socket"    => "--socket",
+            "username"  => "--user",
+            "password"  => "--password",
+            "encoding"  => "--default-character-set",
+            "sslca"     => "--ssl-ca",
+            "sslcert"   => "--ssl-cert",
+            "sslcapath" => "--ssl-capath",
+            "sslcipher" => "--ssl-cipher",
+            "sslkey"    => "--ssl-key"
+          }.map { |opt, arg| "#{arg}=#{configuration[opt]}" if configuration[opt] }.compact
+
+          args
+        end
 
-      def run_cmd(cmd, args, action)
-        fail run_cmd_error(cmd, args, action) unless Kernel.system(cmd, *args)
-      end
+        def run_cmd(cmd, args, action)
+          fail run_cmd_error(cmd, args, action) unless Kernel.system(cmd, *args)
+        end
 
-      def run_cmd_error(cmd, args, action)
-        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
+        def run_cmd_error(cmd, args, action)
+          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
     end
   end
 end

data/lib/active_record/tasks/postgresql_database_tasks.rb

@@ -1,7 +1,8 @@
 module ActiveRecord
   module Tasks # :nodoc:
     class PostgreSQLDatabaseTasks # :nodoc:
-      DEFAULT_ENCODING = ENV['CHARSET'] || 'utf8'
+      DEFAULT_ENCODING = ENV["CHARSET"] || "utf8"
+      ON_ERROR_STOP_1 = "ON_ERROR_STOP=1".freeze
 
       delegate :connection, :establish_connection, :clear_active_connections!,
         to: ActiveRecord::Base
@@ -12,11 +13,11 @@ module ActiveRecord
 
       def create(master_established = false)
         establish_master_connection unless master_established
-        connection.create_database configuration['database'],
-          configuration.merge('encoding' => encoding)
+        connection.create_database configuration["database"],
+          configuration.merge("encoding" => encoding)
         establish_connection configuration
       rescue ActiveRecord::StatementInvalid => error
-        if error.cause.is_a?(PG::DuplicateDatabase)
+        if /database .* already exists/.match?(error.message)
           raise DatabaseAlreadyExists
         else
           raise
@@ -25,7 +26,7 @@ module ActiveRecord
 
       def drop
         establish_master_connection
-        connection.drop_database configuration['database']
+        connection.drop_database configuration["database"]
       end
 
       def charset
@@ -42,69 +43,73 @@ module ActiveRecord
         create true
       end
 
-      def structure_dump(filename)
+      def structure_dump(filename, extra_flags)
         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
+        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]
+        args = ["-s", "-x", "-O", "-f", filename]
+        args.concat(Array(extra_flags)) if extra_flags
         unless search_path.blank?
-          args += search_path.split(',').map do |part|
+          args += search_path.split(",").map do |part|
             "--schema=#{part.strip}"
           end
         end
-        args << configuration['database']
-        run_cmd('pg_dump', args, 'dumping')
+        args << configuration["database"]
+        run_cmd("pg_dump", args, "dumping")
         File.open(filename, "a") { |f| f << "SET search_path TO #{connection.schema_search_path};\n\n" }
       end
 
-      def structure_load(filename)
+      def structure_load(filename, extra_flags)
         set_psql_env
-        args = [ '-q', '-f', filename, configuration['database'] ]
-        run_cmd('psql', args, 'loading' )
+        args = ["-v", ON_ERROR_STOP_1, "-q", "-f", filename]
+        args.concat(Array(extra_flags)) if extra_flags
+        args << configuration["database"]
+        run_cmd("psql", args, "loading")
       end
 
       private
 
-      def configuration
-        @configuration
-      end
+        def configuration
+          @configuration
+        end
 
-      def encoding
-        configuration['encoding'] || DEFAULT_ENCODING
-      end
+        def encoding
+          configuration["encoding"] || DEFAULT_ENCODING
+        end
 
-      def establish_master_connection
-        establish_connection configuration.merge(
-          'database'           => 'postgres',
-          'schema_search_path' => 'public'
-        )
-      end
+        def establish_master_connection
+          establish_connection configuration.merge(
+            "database"           => "postgres",
+            "schema_search_path" => "public"
+          )
+        end
 
-      def set_psql_env
-        ENV['PGHOST']     = configuration['host']          if configuration['host']
-        ENV['PGPORT']     = configuration['port'].to_s     if configuration['port']
-        ENV['PGPASSWORD'] = configuration['password'].to_s if configuration['password']
-        ENV['PGUSER']     = configuration['username'].to_s if configuration['username']
-      end
+        def set_psql_env
+          ENV["PGHOST"]     = configuration["host"]          if configuration["host"]
+          ENV["PGPORT"]     = configuration["port"].to_s     if configuration["port"]
+          ENV["PGPASSWORD"] = configuration["password"].to_s if configuration["password"]
+          ENV["PGUSER"]     = configuration["username"].to_s if configuration["username"]
+        end
 
-      def run_cmd(cmd, args, action)
-        fail run_cmd_error(cmd, args, action) unless Kernel.system(cmd, *args)
-      end
+        def run_cmd(cmd, args, action)
+          fail run_cmd_error(cmd, args, action) unless Kernel.system(cmd, *args)
+        end
 
-      def run_cmd_error(cmd, args, action)
-        msg = "failed to execute:\n"
-        msg << "#{cmd} #{args.join(' ')}\n\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
+        def run_cmd_error(cmd, args, action)
+          msg = "failed to execute:\n"
+          msg << "#{cmd} #{args.join(' ')}\n\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
     end
   end
 end

data/lib/active_record/tasks/sqlite_database_tasks.rb

@@ -8,20 +8,20 @@ module ActiveRecord
       end
 
       def create
-        raise DatabaseAlreadyExists if File.exist?(configuration['database'])
+        raise DatabaseAlreadyExists if File.exist?(configuration["database"])
 
         establish_connection configuration
         connection
       end
 
       def drop
-        require 'pathname'
-        path = Pathname.new configuration['database']
+        require "pathname"
+        path = Pathname.new configuration["database"]
         file = path.absolute? ? path.to_s : File.join(root, path)
 
         FileUtils.rm(file)
       rescue Errno::ENOENT => error
-        raise NoDatabaseError.new(error.message, error)
+        raise NoDatabaseError.new(error.message)
       end
 
       def purge
@@ -35,25 +35,27 @@ module ActiveRecord
         connection.encoding
       end
 
-      def structure_dump(filename)
-        dbfile = configuration['database']
-        `sqlite3 #{dbfile} .schema > #{filename}`
+      def structure_dump(filename, extra_flags)
+        dbfile = configuration["database"]
+        flags = extra_flags.join(" ") if extra_flags
+        `sqlite3 #{flags} #{dbfile} .schema > #{filename}`
       end
 
-      def structure_load(filename)
-        dbfile = configuration['database']
-        `sqlite3 #{dbfile} < "#{filename}"`
+      def structure_load(filename, extra_flags)
+        dbfile = configuration["database"]
+        flags = extra_flags.join(" ") if extra_flags
+        `sqlite3 #{flags} #{dbfile} < "#{filename}"`
       end
 
       private
 
-      def configuration
-        @configuration
-      end
+        def configuration
+          @configuration
+        end
 
-      def root
-        @root
-      end
+        def root
+          @root
+        end
     end
   end
 end

data/lib/active_record/timestamp.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module ActiveRecord
   # = Active Record \Timestamp
   #
@@ -51,15 +52,41 @@ module ActiveRecord
       clear_timestamp_attributes
     end
 
+    class_methods do
+      private
+        def timestamp_attributes_for_create_in_model
+          timestamp_attributes_for_create.select { |c| column_names.include?(c) }
+        end
+
+        def timestamp_attributes_for_update_in_model
+          timestamp_attributes_for_update.select { |c| column_names.include?(c) }
+        end
+
+        def all_timestamp_attributes_in_model
+          timestamp_attributes_for_create_in_model + timestamp_attributes_for_update_in_model
+        end
+
+        def timestamp_attributes_for_create
+          ["created_at", "created_on"]
+        end
+
+        def timestamp_attributes_for_update
+          ["updated_at", "updated_on"]
+        end
+
+        def current_time_from_proper_timezone
+          default_timezone == :utc ? Time.now.utc : Time.now
+        end
+    end
+
   private
 
     def _create_record
-      if self.record_timestamps
+      if record_timestamps
         current_time = current_time_from_proper_timezone
 
-        all_timestamp_attributes.each do |column|
-          column = column.to_s
-          if has_attribute?(column) && !attribute_present?(column)
+        all_timestamp_attributes_in_model.each do |column|
+          if !attribute_present?(column)
             write_attribute(column, current_time)
           end
         end
@@ -73,8 +100,7 @@ module ActiveRecord
         current_time = current_time_from_proper_timezone
 
         timestamp_attributes_for_update_in_model.each do |column|
-          column = column.to_s
-          next if attribute_changed?(column)
+          next if will_save_change_to_attribute?(column)
           write_attribute(column, current_time)
         end
       end
@@ -82,34 +108,26 @@ module ActiveRecord
     end
 
     def should_record_timestamps?
-      self.record_timestamps && (!partial_writes? || changed?)
+      record_timestamps && (!partial_writes? || has_changes_to_save?)
     end
 
     def timestamp_attributes_for_create_in_model
-      timestamp_attributes_for_create.select { |c| self.class.column_names.include?(c.to_s) }
+      self.class.send(:timestamp_attributes_for_create_in_model)
     end
 
     def timestamp_attributes_for_update_in_model
-      timestamp_attributes_for_update.select { |c| self.class.column_names.include?(c.to_s) }
+      self.class.send(:timestamp_attributes_for_update_in_model)
     end
 
     def all_timestamp_attributes_in_model
-      timestamp_attributes_for_create_in_model + timestamp_attributes_for_update_in_model
-    end
-
-    def timestamp_attributes_for_update
-      [:updated_at, :updated_on]
-    end
-
-    def timestamp_attributes_for_create
-      [:created_at, :created_on]
+      self.class.send(:all_timestamp_attributes_in_model)
     end
 
-    def all_timestamp_attributes
-      timestamp_attributes_for_create + timestamp_attributes_for_update
+    def current_time_from_proper_timezone
+      self.class.send(:current_time_from_proper_timezone)
     end
 
-    def max_updated_column_timestamp(timestamp_names = timestamp_attributes_for_update)
+    def max_updated_column_timestamp(timestamp_names = self.class.send(:timestamp_attributes_for_update))
       timestamp_names
         .map { |attr| self[attr] }
         .compact
@@ -117,10 +135,6 @@ module ActiveRecord
         .max
     end
 
-    def current_time_from_proper_timezone
-      self.class.default_timezone == :utc ? Time.now.utc : Time.now
-    end
-
     # Clear attributes and changed_attributes
     def clear_timestamp_attributes
       all_timestamp_attributes_in_model.each do |attribute_name|