merge album and folder models

scanner/folder_stack.go

@@ -1,35 +1,40 @@
 package scanner
 
-import "github.com/sentriz/gonic/model"
+import (
+	"fmt"
+	"strings"
 
-type folderStack []model.Folder
+	"github.com/sentriz/gonic/model"
+)
 
-func (s *folderStack) Push(v model.Folder) {
+type folderStack []*model.Folder
+
+func (s *folderStack) Push(v *model.Folder) {
 	*s = append(*s, v)
 }
 
-func (s *folderStack) Pop() model.Folder {
+func (s *folderStack) Pop() *model.Folder {
 	l := len(*s)
 	if l == 0 {
-		return model.Folder{}
+		return nil
 	}
 	r := (*s)[l-1]
 	*s = (*s)[:l-1]
 	return r
 }
 
-func (s *folderStack) Peek() model.Folder {
+func (s *folderStack) Peek() *model.Folder {
 	l := len(*s)
 	if l == 0 {
-		return model.Folder{}
+		return nil
 	}
 	return (*s)[l-1]
 }
 
-func (s *folderStack) PeekID() int {
-	l := len(*s)
-	if l == 0 {
-		return 0
+func (s *folderStack) String() string {
+	paths := make([]string, len(*s))
+	for i, folder := range *s {
+		paths[i] = folder.RightPath
 	}
-	return (*s)[l-1].ID
+	return fmt.Sprintf("[%s]", strings.Join(paths, " "))
 }

scanner/scanner.go

@@ -1,12 +1,5 @@
 package scanner
 
-// Album  -> needs a  CoverID
-//        -> needs a  FolderID (American Football)
-// Folder -> needs a  CoverID
-//        -> needs a  ParentID
-// Track  -> needs an AlbumID
-//        -> needs a  FolderID
-
 import (
 	"log"
 	"sync/atomic"
@@ -26,27 +19,32 @@ var (
 type Scanner struct {
 	db, tx     *gorm.DB
 	musicPath  string
-	seenTracks map[string]bool
+	seenTracks map[int]struct{}
 	curFolders folderStack
-	curTracks  []model.Track
-	curCover   model.Cover
-	curAlbum   model.Album
-	curAArtist model.Artist
+	curCover   string
 }
 
 func New(db *gorm.DB, musicPath string) *Scanner {
 	return &Scanner{
 		db:         db,
 		musicPath:  musicPath,
-		seenTracks: make(map[string]bool),
+		seenTracks: make(map[int]struct{}),
 		curFolders: make(folderStack, 0),
-		curTracks:  make([]model.Track, 0),
-		curCover:   model.Cover{},
-		curAlbum:   model.Album{},
-		curAArtist: model.Artist{},
 	}
 }
 
+func (s *Scanner) curFolder() *model.Folder {
+	return s.curFolders.Peek()
+}
+
+func (s *Scanner) curFolderID() int {
+	peek := s.curFolders.Peek()
+	if peek == nil {
+		return 0
+	}
+	return peek.ID
+}
+
 func (s *Scanner) Start() error {
 	if atomic.LoadInt32(&IsScanning) == 1 {
 		return errors.New("already scanning")
@@ -86,16 +84,17 @@ func (s *Scanner) startClean() error {
 	defer logElapsed(time.Now(), "cleaning database")
 	var tracks []model.Track
 	s.tx.
-		Select("id, path").
+		Select("id").
 		Find(&tracks)
+	var deleted int
 	for _, track := range tracks {
-		_, ok := s.seenTracks[track.Path]
-		if ok {
-			continue
+		_, ok := s.seenTracks[track.ID]
+		if !ok {
+			s.tx.Delete(&track)
+			deleted++
 		}
-		s.tx.Delete(&track)
-		log.Println("removed track", track.Path)
 	}
+	log.Printf("removed %d tracks\n", deleted)
 	return nil
 }
 
@@ -104,10 +103,8 @@ func (s *Scanner) MigrateDB() error {
 	s.tx = s.db.Begin()
 	defer s.tx.Commit()
 	s.tx.AutoMigrate(
-		model.Album{},
 		model.Artist{},
 		model.Track{},
-		model.Cover{},
 		model.User{},
 		model.Setting{},
 		model.Play{},

scanner/utilities.go

@@ -2,15 +2,12 @@ package scanner
 
 import (
 	"os"
-	"path"
-	"path/filepath"
-	"strings"
 
 	"github.com/dhowden/tag"
 	"github.com/pkg/errors"
 )
 
-var trackExtensions = map[string]string{
+var mimeTypes = map[string]string{
 	"mp3":  "audio/mpeg",
 	"flac": "audio/x-flac",
 	"aac":  "audio/x-aac",
@@ -18,15 +15,6 @@ var trackExtensions = map[string]string{
 	"ogg":  "audio/ogg",
 }
 
-func isTrack(fullPath string) (string, string, bool) {
-	ext := filepath.Ext(fullPath)[1:]
-	mine, ok := trackExtensions[ext]
-	if !ok {
-		return "", "", false
-	}
-	return mine, ext, true
-}
-
 var coverFilenames = map[string]struct{}{
 	"cover.png":   struct{}{},
 	"cover.jpg":   struct{}{},
@@ -42,12 +30,6 @@ var coverFilenames = map[string]struct{}{
 	"front.jpeg":  struct{}{},
 }
 
-func isCover(fullPath string) bool {
-	_, filename := path.Split(fullPath)
-	_, ok := coverFilenames[strings.ToLower(filename)]
-	return ok
-}
-
 func readTags(path string) (tag.Metadata, error) {
 	trackData, err := os.Open(path)
 	if err != nil {

scanner/walk.go

@@ -1,7 +1,6 @@
 package scanner
 
 import (
-	"io/ioutil"
 	"log"
 	"os"
 	"path"
@@ -14,182 +13,146 @@ import (
 	"github.com/sentriz/gonic/model"
 )
 
-type trackItem struct {
-	mime string
-	ext  string
-}
-
 type item struct {
-	path    string
-	relPath string
-	stat    os.FileInfo
-	track   *trackItem
+	//
+	// common
+	fullPath  string
+	relPath   string
+	directory string
+	filename  string
+	stat      os.FileInfo
+	//
+	// track only
+	ext  string
+	mime string
 }
 
-func (s *Scanner) callbackItem(path string, info *godirwalk.Dirent) error {
-	stat, err := os.Stat(path)
+func (s *Scanner) callbackItem(fullPath string, info *godirwalk.Dirent) error {
+	stat, err := os.Stat(fullPath)
 	if err != nil {
 		return errors.Wrap(err, "stating")
 	}
-	relPath, err := filepath.Rel(s.musicPath, path)
+	relPath, err := filepath.Rel(s.musicPath, fullPath)
 	if err != nil {
 		return errors.Wrap(err, "getting relative path")
 	}
+	directory, filename := path.Split(relPath)
 	it := &item{
-		path:    path,
-		relPath: relPath,
-		stat:    stat,
+		fullPath:  fullPath,
+		relPath:   relPath,
+		directory: directory,
+		filename:  filename,
+		stat:      stat,
 	}
 	if info.IsDir() {
 		return s.handleFolder(it)
 	}
-	if isCover(path) {
-		return s.handleCover(it)
+	if _, ok := coverFilenames[filename]; ok {
+		s.curCover = filename
+		return nil
 	}
-	if mime, ext, ok := isTrack(path); ok {
-		s.seenTracks[relPath] = true
-		it.track = &trackItem{mime: mime, ext: ext}
+	ext := path.Ext(filename)[1:]
+	if mime, ok := mimeTypes[ext]; ok {
+		it.ext = ext
+		it.mime = mime
 		return s.handleTrack(it)
 	}
 	return nil
 }
 
-func (s *Scanner) callbackPost(path string, info *godirwalk.Dirent) error {
-	// in general in this function - if a model is not nil, then it
-	// has at least been looked up. if it has a id of 0, then it is
-	// a new record and needs to be inserted
-	if s.curCover.IsNew {
-		s.tx.Save(&s.curCover)
-	}
-	if s.curAlbum.IsNew {
-		s.curAlbum.CoverID = s.curCover.ID
-		s.tx.Save(&s.curAlbum)
-	}
+func (s *Scanner) callbackPost(fullPath string, info *godirwalk.Dirent) error {
 	folder := s.curFolders.Pop()
 	if folder.IsNew {
-		folder.ParentID = s.curFolders.PeekID()
-		folder.CoverID = s.curCover.ID
-		folder.HasTracks = len(s.curTracks) > 1
+		folder.ParentID = s.curFolderID()
+		folder.Cover = s.curCover
 		s.tx.Save(&folder)
 	}
-	for _, t := range s.curTracks {
-		t.FolderID = folder.ID
-		t.AlbumID = s.curAlbum.ID
-		s.tx.Save(&t)
-	}
-	//
-	s.curTracks = make([]model.Track, 0)
-	s.curCover = model.Cover{}
-	s.curAlbum = model.Album{}
-	s.curAArtist = model.Artist{}
-	//
-	log.Printf("processed folder `%s`\n", path)
+	s.curCover = ""
+	log.Printf("processed folder `%s`\n", fullPath)
 	return nil
 }
 
 func (s *Scanner) handleFolder(it *item) error {
-	// TODO:
 	var folder model.Folder
 	err := s.tx.
-		Where("path = ?", it.relPath).
+		Where(model.Folder{
+			LeftPath:  it.directory,
+			RightPath: it.filename,
+		}).
 		First(&folder).
 		Error
 	if !gorm.IsRecordNotFoundError(err) &&
 		it.stat.ModTime().Before(folder.UpdatedAt) {
 		// we found the record but it hasn't changed
-		s.curFolders.Push(folder)
+		s.curFolders.Push(&folder)
 		return nil
 	}
-	folder.Path = it.relPath
-	folder.Name = it.stat.Name()
+	folder.LeftPath = it.directory
+	folder.RightPath = it.filename
 	s.tx.Save(&folder)
 	folder.IsNew = true
-	s.curFolders.Push(folder)
-	return nil
-}
-
-func (s *Scanner) handleCover(it *item) error {
-	err := s.tx.
-		Where("path = ?", it.relPath).
-		First(&s.curCover).
-		Error
-	if !gorm.IsRecordNotFoundError(err) &&
-		it.stat.ModTime().Before(s.curCover.UpdatedAt) {
-		// we found the record but it hasn't changed
-		return nil
-	}
-	s.curCover.Path = it.relPath
-	image, err := ioutil.ReadFile(it.path)
-	if err != nil {
-		return errors.Wrap(err, "reading cover")
-	}
-	s.curCover.Image = image
-	s.curCover.IsNew = true
+	s.curFolders.Push(&folder)
 	return nil
 }
 
 func (s *Scanner) handleTrack(it *item) error {
 	//
 	// set track basics
-	track := model.Track{}
+	var track model.Track
 	err := s.tx.
-		Where("path = ?", it.relPath).
+		Where(model.Track{
+			FolderID: s.curFolderID(),
+			Filename: it.filename,
+			Ext:      it.ext,
+		}).
 		First(&track).
 		Error
 	if !gorm.IsRecordNotFoundError(err) &&
 		it.stat.ModTime().Before(track.UpdatedAt) {
+		s.seenTracks[track.ID] = struct{}{}
 		// we found the record but it hasn't changed
 		return nil
 	}
-	tags, err := readTags(it.path)
+	track.Filename = it.filename
+	track.Ext = it.ext
+	track.ContentType = it.mime
+	track.Size = int(it.stat.Size())
+	track.FolderID = s.curFolderID()
+	track.Duration = -1
+	track.Bitrate = -1
+	tags, err := readTags(it.fullPath)
 	if err != nil {
 		return errors.Wrap(err, "reading tags")
 	}
 	trackNumber, totalTracks := tags.Track()
 	discNumber, totalDiscs := tags.Disc()
-	track.DiscNumber = discNumber
-	track.TotalDiscs = totalDiscs
-	track.TotalTracks = totalTracks
-	track.TrackNumber = trackNumber
-	track.Path = it.relPath
-	track.Suffix = it.track.ext
-	track.ContentType = it.track.mime
-	track.Size = int(it.stat.Size())
-	track.Title = tags.Title()
-	track.TrackArtist = tags.Artist()
-	track.Year = tags.Year()
-	track.FolderID = s.curFolders.PeekID()
+	track.TagDiscNumber = discNumber
+	track.TagTotalDiscs = totalDiscs
+	track.TagTotalTracks = totalTracks
+	track.TagTrackNumber = trackNumber
+	track.TagTitle = tags.Title()
+	track.TagTrackArtist = tags.Artist()
+	track.TagYear = tags.Year()
 	//
 	// set album artist basics
+	var artist model.Artist
 	err = s.tx.Where("name = ?", tags.AlbumArtist()).
-		First(&s.curAArtist).
+		First(&artist).
 		Error
 	if gorm.IsRecordNotFoundError(err) {
-		s.curAArtist.Name = tags.AlbumArtist()
-		s.tx.Save(&s.curAArtist)
+		artist.Name = tags.AlbumArtist()
+		s.tx.Save(&artist)
 	}
-	track.ArtistID = s.curAArtist.ID
+	track.ArtistID = artist.ID
+	s.tx.Save(&track)
+	s.seenTracks[track.ID] = struct{}{}
 	//
 	// set album if this is the first track in the folder
-	if len(s.curTracks) > 0 {
-		s.curTracks = append(s.curTracks, track)
+	if !s.curFolder().IsNew {
 		return nil
 	}
-	s.curTracks = append(s.curTracks, track)
-	//
-	directory, _ := path.Split(it.relPath)
-	err = s.tx.
-		Where("path = ?", directory).
-		First(&s.curAlbum).
-		Error
-	if !gorm.IsRecordNotFoundError(err) {
-		// we found the record
-		return nil
-	}
-	s.curAlbum.Path = directory
-	s.curAlbum.Title = tags.Album()
-	s.curAlbum.Year = tags.Year()
-	s.curAlbum.ArtistID = s.curAArtist.ID
-	s.curAlbum.IsNew = true
+	s.curFolder().AlbumTitle = tags.Album()
+	s.curFolder().AlbumYear = tags.Year()
+	s.curFolder().AlbumArtistID = artist.ID
 	return nil
 }