migrate: rename PostStepCallback to MigrationTask

Author: ViktorT-11

migrate.go

@@ -55,58 +55,56 @@ func (e ErrDirty) Error() string {
 	return fmt.Sprintf("Dirty database version %v. Fix and force version.", e.Version)
 }
 
-// PostStepCallback is a callback function type that can be used to execute a
+// MigrationTask is a callback function type that can be used to execute a
 // Golang based migration step after a SQL based migration step has been
 // executed. The callback function receives the migration and the database
 // driver as arguments.
-type PostStepCallback func(migr *Migration, driver database.Driver) error
+type MigrationTask func(migr *Migration, driver database.Driver) error
 
 // options is a set of optional options that can be set when a Migrate instance
 // is created.
 type options struct {
-	// postStepCallbacks is a map of PostStepCallback functions that can be
-	// used to execute a Golang based migration step after a SQL based
-	// migration step has been executed. The key is the migration version
-	// and the value is the callback function that should be run _after_ the
-	// step was executed (but within the same database transaction).
-	postStepCallbacks map[uint]PostStepCallback
+	// tasks is a map of MigrationTask functions that can be used to execute
+	// a Golang based migration step after a SQL based migration step ha
+	// been executed. The key is the migration version and the value is the
+	// callback function that should be run _after_ the step was executed
+	// (but within the same database transaction).
+	tasks map[uint]MigrationTask
 }
 
 // defaultOptions returns a new options struct with default values.
 func defaultOptions() options {
 	return options{
-		postStepCallbacks: make(map[uint]PostStepCallback),
+		tasks: make(map[uint]MigrationTask),
 	}
 }
 
 // Option is a function that can be used to set options on a Migrate instance.
 type Option func(*options)
 
-// WithPostStepCallbacks is an option that can be used to set a map of
-// PostStepCallback functions that can be used to execute a Golang based
-// migration step after a SQL based migration step has been executed. The key is
-// the migration version and the value is the callback function that should be
-// run _after_ the step was executed (but before the version is marked as
-// cleanly executed). An error returned from the callback will cause the
-// migration to fail and the step to be marked as dirty.
-func WithPostStepCallbacks(
-	postStepCallbacks map[uint]PostStepCallback) Option {
-
+// WithMigrationTasks is an option that can be used to set a map of
+// MigrationTask functions that can be used to execute a Golang based migration
+// step after a SQL based migration step has been executed. The key is the
+// migration version and the value is the task function that should be run
+// _after_ the step was executed (but before the version is marked as cleanly
+// executed). An error returned from the task will cause the migration to fail
+// and the step to be marked as dirty.
+func WithMigrationTasks(tasks map[uint]MigrationTask) Option {
 	return func(o *options) {
-		o.postStepCallbacks = postStepCallbacks
+		o.tasks = tasks
 	}
 }
 
-// WithPostStepCallback is an option that can be used to set a PostStepCallback
+// WithMigrationTask is an option that can be used to set a MigrationTask
 // function that can be used to execute a Golang based migration step after the
 // SQL based migration step with the given version number has been executed. The
-// callback is the function that should be run _after_ the step was executed
+// task is the function that should be run _after_ the step was executed
 // (but before the version is marked as cleanly executed). An error returned
-// from the callback will cause the migration to fail and the step to be marked
-// as dirty.
-func WithPostStepCallback(version uint, callback PostStepCallback) Option {
+// from the task will cause the migration to fail and the step to be marked as
+// dirty.
+func WithMigrationTask(version uint, task MigrationTask) Option {
 	return func(o *options) {
-		o.postStepCallbacks[version] = callback
+		o.tasks[version] = task
 	}
 }
 
@@ -818,22 +816,22 @@ func (m *Migrate) runMigrations(ret <-chan interface{}) error {
 					return err
 				}
 
-				// If there is a post execution function for
-				// this migration, run it now.
-				cb, ok := m.opts.postStepCallbacks[migr.Version]
+				// If there is a task function for this
+				// migration, run it now.
+				cb, ok := m.opts.tasks[migr.Version]
 				if ok {
-					m.logVerbosePrintf("Running post step "+
-						"callback for %v\n", migr.LogString())
+					m.logVerbosePrintf("Running migration "+
+						"task for %v\n", migr.LogString())
 
 					err := cb(migr, m.databaseDrv)
 					if err != nil {
 						return fmt.Errorf("failed to "+
-							"execute post "+
-							"step callback: %w",
+							"execute migration "+
+							"task: %w",
 							err)
 					}
 
-					m.logVerbosePrintf("Post step callback "+
+					m.logVerbosePrintf("Migration task "+
 						"finished for %v\n", migr.LogString())
 				}
 			}

migrate_test.go

@@ -879,9 +879,9 @@ func TestUpAndDown(t *testing.T) {
 	equalDbSeq(t, 1, expectedSequence, dbDrv)
 }
 
-func TestPostStepCallback(t *testing.T) {
-	m, _ := New("stub://", "stub://", WithPostStepCallbacks(
-		map[uint]PostStepCallback{
+func TestMigrationTask(t *testing.T) {
+	m, _ := New("stub://", "stub://", WithMigrationTasks(
+		map[uint]MigrationTask{
 			1: func(m *Migration, driver database.Driver) error {
 				return driver.Run(
 					strings.NewReader("CALLBACK 1"),