chore: improve readability of popx.MigrationBox

GitOrigin-RevId: e7e413764d7e4084f2d9ee4313e5f1405c807a10

Author: hperl

oryx/popx/match.go

@@ -15,6 +15,16 @@ var MigrationFileRegexp = regexp.MustCompile(
 	`^(\d+)_([^.]+)(\.[a-z0-9]+)?(\.autocommit)?\.(up|down)\.(sql)$`,
 )
 
+const (
+	// Human-readable constants for the regex capture groups
+	versionIdx = iota + 1
+	nameIdx
+	dbTypeIdx
+	autocommitIdx
+	directionIdx
+	typeIdx
+)
+
 // match holds the information parsed from a migration filename.
 type match struct {
 	Version    string
@@ -33,37 +43,40 @@ func parseMigrationFilename(filename string) (*match, error) {
 	}
 	m := matches[0]
 
-	var autocommit bool
-	var dbType string
-	if m[3] == ".autocommit" {
+	var (
+		autocommit bool
+		dbType     string
+	)
+
+	if m[dbTypeIdx] == ".autocommit" {
 		// A special case where autocommit group moves forward to the 3rd index.
 		autocommit = true
 		dbType = "all"
-	} else if m[3] == "" {
+	} else if m[dbTypeIdx] == "" {
 		dbType = "all"
 	} else {
-		dbType = pop.CanonicalDialect(m[3][1:])
+		dbType = pop.CanonicalDialect(m[dbTypeIdx][1:])
 		if !pop.DialectSupported(dbType) {
 			return nil, errors.Errorf("unsupported dialect %s", dbType)
 		}
 	}
 
-	if m[6] == "fizz" && dbType != "all" {
+	if m[typeIdx] == "fizz" && dbType != "all" {
 		return nil, errors.Errorf("invalid database type %q, expected \"all\" because fizz is database type independent", dbType)
 	}
 
-	if m[4] == ".autocommit" {
+	if m[autocommitIdx] == ".autocommit" {
 		autocommit = true
-	} else if m[4] != "" {
-		return nil, errors.Errorf("invalid autocommit flag %q", m[4])
+	} else if m[autocommitIdx] != "" {
+		return nil, errors.Errorf("invalid autocommit flag %q", m[autocommitIdx])
 	}
 
 	return &match{
-		Version:    m[1],
-		Name:       m[2],
+		Version:    m[versionIdx],
+		Name:       m[nameIdx],
 		DBType:     dbType,
 		Autocommit: autocommit,
-		Direction:  m[5],
-		Type:       m[6],
+		Direction:  m[directionIdx],
+		Type:       m[typeIdx],
 	}, nil
 }

oryx/popx/migration_box.go

@@ -108,7 +108,7 @@ func WithTestdata(t *testing.T, testdata fs.FS) MigrationBoxOption {
 				flavor = pop.CanonicalDialect(strings.TrimPrefix(match[2], "."))
 			}
 
-			//t.Logf("Found test migration \"%s\" (%s, %+v): %s", flavor, match, err, info.Name())
+			// t.Logf("Found test migration \"%s\" (%s, %+v): %s", flavor, match, err, info.Name())
 
 			m.migrationsUp = append(m.migrationsUp, Migration{
 				Version:   version + "9", // run testdata after version

oryx/popx/migration_info.go

@@ -63,23 +63,40 @@ func compareMigration(a, b Migration) int {
 	return strings.Compare(a.DBType, b.DBType)
 }
 
+// specificity returns an integer representing how specific the migration is.
+// Higher numbers indicate a more specific migration.
+func specificity(m *Migration) int {
+	specificity := 0
+	if m.DBType != "all" {
+		specificity += 1
+	}
+
+	return specificity
+}
+
+// isApplicable checks whether the migration is applicable for the given dialect.
+func isApplicable(m Migration, dialect string) bool {
+	return m.DBType == dialect || m.DBType == "all"
+}
+
 func (mfs Migrations) sortAndFilter(dialect string) Migrations {
-	usable := make(map[string]Migration, len(mfs))
-	for _, v := range mfs {
-		if v.DBType == dialect {
-			usable[v.Version] = v
-		} else if v.DBType == "all" {
-			// Add "all" only if we do not have a more specific migration for the dialect.
-			// If a more specific migration is found later, it will override this one.
-			if _, ok := usable[v.Version]; !ok {
-				usable[v.Version] = v
+	byVersion := make(map[string]Migration, len(mfs))
+	for _, migration := range mfs {
+		if !isApplicable(migration, dialect) {
+			continue
+		}
+		if previousMigration, ok := byVersion[migration.Version]; ok {
+			if specificity(&migration) < specificity(&previousMigration) {
+				// Previous migration is more specific, skip this one.
+				continue
 			}
 		}
+		byVersion[migration.Version] = migration
 	}
 
-	filtered := make(Migrations, 0, len(usable))
-	for k := range usable {
-		filtered = append(filtered, usable[k])
+	filtered := make(Migrations, 0, len(byVersion))
+	for k := range byVersion {
+		filtered = append(filtered, byVersion[k])
 	}
 	sort.Sort(filtered)
 	return filtered