feat: add genre-tree option to expand genre hierarchies

Author: sentriz

cmd/gonic/gonic.go

@@ -46,6 +46,7 @@ import (
 	"go.senan.xyz/gonic/scrobble"
 	"go.senan.xyz/gonic/server/ctrladmin"
 	"go.senan.xyz/gonic/server/ctrlsubsonic"
+	"go.senan.xyz/gonic/texttree"
 	"go.senan.xyz/gonic/transcode"
 )
 
@@ -82,6 +83,7 @@ func main() {
 	confConfigPath := flag.String("config-path", "", "path to config (optional)")
 
 	confExcludePattern := flag.String("exclude-pattern", "", "regex pattern to exclude files from scan (optional)")
+	confGenreTree := flag.String("genre-tree", "", "path to a tab-separated genre tree file for hierarchical genre browsing (optional)")
 
 	var confMultiValueGenre, confMultiValueArtist, confMultiValueAlbumArtist multiValueSetting
 	flag.Var(&confMultiValueGenre, "multi-value-genre", "setting for multi-valued genre scanning (optional)")
@@ -184,6 +186,14 @@ func main() {
 		log.Printf("    %-30s %s\n", f.Name, value)
 	})
 
+	var genreTree map[string][]string
+	if *confGenreTree != "" {
+		genreTree, err = texttree.ParseFile(*confGenreTree)
+		if err != nil {
+			log.Fatalf("error parsing genre tree: %v\n", err)
+		}
+	}
+
 	tagReader := deps.TagReader
 
 	scannr := scanner.New(
@@ -197,6 +207,7 @@ func main() {
 		tagReader,
 		*confExcludePattern,
 		*confScanEmbeddedCover,
+		genreTree,
 	)
 	podcast := podcast.New(dbc, *confPodcastPath, tagReader)
 	transcoder := transcode.NewCachingTranscoder(

db/db.go

@@ -54,19 +54,30 @@ func NewMock(opts url.Values) (*DB, error) {
 }
 
 func (db *DB) InsertBulkLeftMany(table string, head []string, left int, col []int) error {
-	if len(col) == 0 {
+	var rows [][]any
+	for _, c := range col {
+		rows = append(rows, []any{c})
+	}
+	return db.InsertBulkLeftManyRows(table, head, left, rows)
+}
+
+func (db *DB) InsertBulkLeftManyRows(table string, head []string, left int, rows [][]any) error {
+	if len(rows) == 0 {
 		return nil
 	}
-	var rows []string
+	extraCols := len(head) - 1
+	placeholders := "(?," + strings.TrimSuffix(strings.Repeat(" ?,", extraCols), ",") + ")"
+	var rowStrs []string
 	var values []any
-	for _, c := range col {
-		rows = append(rows, "(?, ?)")
-		values = append(values, left, c)
+	for _, row := range rows {
+		rowStrs = append(rowStrs, placeholders)
+		values = append(values, left)
+		values = append(values, row...)
 	}
 	q := fmt.Sprintf("INSERT OR IGNORE INTO %q (%s) VALUES %s",
 		table,
 		strings.Join(head, ", "),
-		strings.Join(rows, ", "),
+		strings.Join(rowStrs, ", "),
 	)
 	return db.Exec(q, values...).Error
 }
@@ -410,13 +421,15 @@ type ArtistAppearances struct {
 }
 
 type TrackGenre struct {
-	TrackID int `gorm:"not null; unique_index:idx_track_id_genre_id" sql:"default: null; type:int REFERENCES tracks(id) ON DELETE CASCADE"`
-	GenreID int `gorm:"not null; unique_index:idx_track_id_genre_id" sql:"default: null; type:int REFERENCES genres(id) ON DELETE CASCADE"`
+	TrackID   int  `gorm:"not null; unique_index:idx_track_id_genre_id" sql:"default: null; type:int REFERENCES tracks(id) ON DELETE CASCADE"`
+	GenreID   int  `gorm:"not null; unique_index:idx_track_id_genre_id" sql:"default: null; type:int REFERENCES genres(id) ON DELETE CASCADE"`
+	Inherited bool `gorm:"not null; default:false"`
 }
 
 type AlbumGenre struct {
-	AlbumID int `gorm:"not null; unique_index:idx_album_id_genre_id" sql:"default: null; type:int REFERENCES albums(id) ON DELETE CASCADE"`
-	GenreID int `gorm:"not null; unique_index:idx_album_id_genre_id" sql:"default: null; type:int REFERENCES genres(id) ON DELETE CASCADE"`
+	AlbumID   int  `gorm:"not null; unique_index:idx_album_id_genre_id" sql:"default: null; type:int REFERENCES albums(id) ON DELETE CASCADE"`
+	GenreID   int  `gorm:"not null; unique_index:idx_album_id_genre_id" sql:"default: null; type:int REFERENCES genres(id) ON DELETE CASCADE"`
+	Inherited bool `gorm:"not null; default:false"`
 }
 
 type AlbumDiscTitle struct {

db/migrations.go

@@ -84,6 +84,7 @@ func (db *DB) Migrate(ctx MigrationContext) error {
 		construct(ctx, "202512021147", migrateAlbumAddIndexOnCreatedAt),
 		construct(ctx, "202601201000", migrateAddAlbumDiscTitles),
 		construct(ctx, "202602061800", migrateAddTrackYear),
+		construct(ctx, "202602281000", migrateAddGenreInherited),
 	}
 
 	return gormigrate.
@@ -899,3 +900,8 @@ func migrateAddTrackYear(tx *gorm.DB, _ MigrationContext) error {
 
 	return nil
 }
+
+func migrateAddGenreInherited(tx *gorm.DB, _ MigrationContext) error {
+	step := tx.AutoMigrate(TrackGenre{}, AlbumGenre{})
+	return step.Error
+}

mockfs/mockfs.go

@@ -69,7 +69,7 @@ func newMockFS(tb testing.TB, dirs []string, excludePattern string) *MockFS {
 	}
 
 	tagReader := &tagReader{paths: map[string]*TagInfo{}}
-	scanner := scanner.New(absDirs, dbc, multiValueSettings, tagReader, excludePattern, true)
+	scanner := scanner.New(absDirs, dbc, multiValueSettings, tagReader, excludePattern, true, nil)
 
 	return &MockFS{
 		t:         tb,

scanner/scanner.go

@@ -43,10 +43,11 @@ type Scanner struct {
 	tagReader          tags.Reader
 	excludePattern     *regexp.Regexp
 	scanEmbeddedCover  bool
+	genreTree          map[string][]string
 	scanning           *int32
 }
 
-func New(musicDirs []string, db *db.DB, multiValueSettings map[Tag]MultiValueSetting, tagReader tags.Reader, excludePattern string, scanEmbeddedCover bool) *Scanner {
+func New(musicDirs []string, db *db.DB, multiValueSettings map[Tag]MultiValueSetting, tagReader tags.Reader, excludePattern string, scanEmbeddedCover bool, genreTree map[string][]string) *Scanner {
 	var excludePatternRegExp *regexp.Regexp
 	if excludePattern != "" {
 		excludePatternRegExp = regexp.MustCompile(excludePattern)
@@ -59,6 +60,7 @@ func New(musicDirs []string, db *db.DB, multiValueSettings map[Tag]MultiValueSet
 		tagReader:          tagReader,
 		excludePattern:     excludePatternRegExp,
 		scanEmbeddedCover:  scanEmbeddedCover,
+		genreTree:          genreTree,
 		scanning:           new(int32),
 	}
 }
@@ -405,6 +407,30 @@ func (s *Scanner) populateTrackAndArtists(tx *db.DB, st *State, i int, album *db
 		return fmt.Errorf("populate genres: %w", err)
 	}
 
+	var inheritedGenreIDs []int
+	if len(s.genreTree) > 0 {
+		direct := map[string]struct{}{}
+		for _, name := range genreNames {
+			direct[name] = struct{}{}
+		}
+		var inheritedNames []string
+		for parent, descendants := range s.genreTree {
+			if _, ok := direct[parent]; ok {
+				continue
+			}
+			for _, desc := range descendants {
+				if _, ok := direct[desc]; ok {
+					inheritedNames = append(inheritedNames, parent)
+					break
+				}
+			}
+		}
+		inheritedGenreIDs, err = populateGenres(tx, inheritedNames)
+		if err != nil {
+			return fmt.Errorf("populate inherited genres: %w", err)
+		}
+	}
+
 	// metadata for the album table comes only from the first track's tags
 	if i == 0 {
 		if err := tx.Where("album_id=?", album.ID).Delete(db.ArtistAppearances{}).Error; err != nil {
@@ -436,7 +462,7 @@ func (s *Scanner) populateTrackAndArtists(tx *db.DB, st *State, i int, album *db
 			return fmt.Errorf("populate album: %w", err)
 		}
 
-		if err := populateAlbumGenres(tx, album, genreIDs); err != nil {
+		if err := populateAlbumGenres(tx, album, genreIDs, inheritedGenreIDs); err != nil {
 			return fmt.Errorf("populate album genres: %w", err)
 		}
 	}
@@ -453,7 +479,7 @@ func (s *Scanner) populateTrackAndArtists(tx *db.DB, st *State, i int, album *db
 	if err := populateTrack(tx, s.scanEmbeddedCover, album, track, trprops, trags, basename, int(stat.Size())); err != nil {
 		return fmt.Errorf("process %q: %w", basename, err)
 	}
-	if err := populateTrackGenres(tx, track, genreIDs); err != nil {
+	if err := populateTrackGenres(tx, track, genreIDs, inheritedGenreIDs); err != nil {
 		return fmt.Errorf("populate track genres: %w", err)
 	}
 
@@ -624,28 +650,48 @@ func populateGenres(tx *db.DB, names []string) ([]int, error) {
 	return ids, nil
 }
 
-func populateTrackGenres(tx *db.DB, track *db.Track, genreIDs []int) error {
+func populateTrackGenres(tx *db.DB, track *db.Track, directIDs, inheritedIDs []int) error {
 	if err := tx.Where("track_id=?", track.ID).Delete(db.TrackGenre{}).Error; err != nil {
 		return fmt.Errorf("delete old track genre records: %w", err)
 	}
-
-	if err := tx.InsertBulkLeftMany("track_genres", []string{"track_id", "genre_id"}, track.ID, genreIDs); err != nil {
-		return fmt.Errorf("insert bulk track genres: %w", err)
+	rows := genreRows(directIDs, inheritedIDs)
+	if err := tx.InsertBulkLeftManyRows("track_genres", []string{"track_id", "genre_id", "inherited"}, track.ID, rows); err != nil {
+		return fmt.Errorf("insert track genres: %w", err)
 	}
 	return nil
 }
 
-func populateAlbumGenres(tx *db.DB, album *db.Album, genreIDs []int) error {
+func populateAlbumGenres(tx *db.DB, album *db.Album, directIDs, inheritedIDs []int) error {
 	if err := tx.Where("album_id=?", album.ID).Delete(db.AlbumGenre{}).Error; err != nil {
 		return fmt.Errorf("delete old album genre records: %w", err)
 	}
-
-	if err := tx.InsertBulkLeftMany("album_genres", []string{"album_id", "genre_id"}, album.ID, genreIDs); err != nil {
-		return fmt.Errorf("insert bulk album genres: %w", err)
+	rows := genreRows(directIDs, inheritedIDs)
+	if err := tx.InsertBulkLeftManyRows("album_genres", []string{"album_id", "genre_id", "inherited"}, album.ID, rows); err != nil {
+		return fmt.Errorf("insert album genres: %w", err)
 	}
 	return nil
 }
 
+func genreRows(directIDs, inheritedIDs []int) [][]any {
+	seen := map[int]struct{}{}
+	var rows [][]any
+	for _, id := range directIDs {
+		if _, ok := seen[id]; ok {
+			continue
+		}
+		seen[id] = struct{}{}
+		rows = append(rows, []any{id, false})
+	}
+	for _, id := range inheritedIDs {
+		if _, ok := seen[id]; ok {
+			continue
+		}
+		seen[id] = struct{}{}
+		rows = append(rows, []any{id, true})
+	}
+	return rows
+}
+
 func populateAlbumDiscTitles(tx *db.DB, album *db.Album, discTitles map[int]string) error {
 	if err := tx.Where("album_id=?", album.ID).Delete(db.AlbumDiscTitle{}).Error; err != nil {
 		return fmt.Errorf("delete old album disc titles: %w", err)

server/ctrlsubsonic/handlers_by_tags.go

@@ -450,7 +450,8 @@ func (c *Controller) ServeGetGenres(_ *http.Request) *spec.Response {
 	c.dbc.
 		Select(`*,
 			(SELECT count(1) FROM album_genres WHERE genre_id=genres.id) album_count,
-			(SELECT count(1) FROM track_genres WHERE genre_id=genres.id) track_count`).
+			(SELECT count(1) FROM track_genres WHERE genre_id=genres.id) track_count
+		`).
 		Group("genres.id").
 		Find(&genres)
 	sub := spec.NewResponse()

texttree/texttree.go

@@ -0,0 +1,100 @@
+package texttree
+
+import (
+	"bufio"
+	"fmt"
+	"io"
+	"os"
+	"strings"
+)
+
+func ParseFile(path string) (map[string][]string, error) {
+	f, err := os.Open(path)
+	if err != nil {
+		return nil, fmt.Errorf("open: %w", err)
+	}
+	defer f.Close()
+	return ParseReader(f)
+}
+
+func ParseReader(r io.Reader) (map[string][]string, error) {
+	children := map[string][]string{} // parent name to its direct children
+	seen := map[string]struct{}{}
+	parents := map[string]string{} // tracks which parent a child belongs to (for duplicate detection)
+
+	scanner := bufio.NewScanner(r)
+	for scanner.Scan() {
+		line := strings.TrimSpace(scanner.Text())
+		if line == "" || strings.HasPrefix(line, "#") {
+			continue
+		}
+
+		parentName, childName, ok := strings.Cut(line, "\t")
+		if !ok {
+			continue
+		}
+
+		parentName = strings.TrimSpace(parentName)
+		childName = strings.TrimSpace(childName)
+		if parentName == "" || childName == "" {
+			continue
+		}
+
+		if _, ok := parents[childName]; ok {
+			return nil, fmt.Errorf("duplicate child in tree: %q", childName)
+		}
+
+		parents[childName] = parentName
+		children[parentName] = append(children[parentName], childName)
+		seen[parentName] = struct{}{}
+		seen[childName] = struct{}{}
+	}
+	if err := scanner.Err(); err != nil {
+		return nil, fmt.Errorf("reading tree: %w", err)
+	}
+
+	for name := range seen {
+		if err := checkCycle(name, parents); err != nil {
+			return nil, err
+		}
+	}
+
+	tree := map[string][]string{}
+	for name := range seen {
+		tree[name] = collectDescendants(name, children)
+	}
+
+	return tree, nil
+}
+
+func checkCycle(name string, parents map[string]string) error {
+	var visited = map[string]bool{}
+	cur := name
+	for {
+		if visited[cur] {
+			return fmt.Errorf("cycle detected in tree at %q", cur)
+		}
+		visited[cur] = true
+		p, ok := parents[cur]
+		if !ok {
+			break
+		}
+		cur = p
+	}
+	return nil
+}
+
+func collectDescendants(name string, children map[string][]string) []string {
+	var result []string
+	var stack []string
+	stack = append(stack, name)
+	for len(stack) > 0 {
+		cur := stack[len(stack)-1]
+		stack = stack[:len(stack)-1]
+		result = append(result, cur)
+		for _, child := range children[cur] {
+			stack = append(stack, child)
+		}
+	}
+	return result
+}

texttree/texttree_test.go

@@ -0,0 +1,39 @@
+package texttree_test
+
+import (
+	"sort"
+	"strings"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	"go.senan.xyz/gonic/texttree"
+)
+
+func TestParseReader(t *testing.T) {
+	tree, err := texttree.ParseReader(strings.NewReader("electronic\tedm\nedm\ttechno\n"))
+	require.NoError(t, err)
+
+	check := func(name string, want []string) {
+		t.Helper()
+		got := append([]string{}, tree[name]...)
+		sort.Strings(got)
+		sort.Strings(want)
+		assert.Equal(t, want, got, name)
+	}
+
+	check("electronic", []string{"edm", "electronic", "techno"})
+	check("edm", []string{"edm", "techno"})
+	check("techno", []string{"techno"})
+}
+
+func TestParseReaderCycle(t *testing.T) {
+	_, err := texttree.ParseReader(strings.NewReader("a\tb\nb\tc\nc\ta\n"))
+	assert.Error(t, err)
+}
+
+func TestParseReaderDuplicateChild(t *testing.T) {
+	_, err := texttree.ParseReader(strings.NewReader("a\tb\nc\tb\n"))
+	assert.Error(t, err)
+}