metadata: refactor cont

Author: rolyatsats

file.go

@@ -12,24 +12,18 @@ import (
   "github.com/jamlib/audioc/metadata"
 )
 
-func (a *audioc) processFile(index int) (*metadata.Metadata, error) {
-  i := &metadata.Info{}
-
-  // if --artist mode, artist is set from flag
-  if a.Config.Artist != "" {
-    i.Artist = a.Config.Artist
-  }
+func (a *audioc) InfoFromConfig(index int) *metadata.Info {
+  i := &metadata.Info{ Artist: a.Config.Artist, Album: a.Config.Album }
 
   // if --collection mode, artist set from parent folder name
   if a.Config.Collection {
     i.Artist = strings.Split(a.Files[index], fsutil.PathSep)[0]
   }
 
-  // if --album mode, album is set from flag
-  if a.Config.Album != "" {
-    i.Album = i.MatchCleanAlbum(a.Config.Album)
-  }
+  return i
+}
 
+func (a *audioc) processFile(index int) (*metadata.Metadata, error) {
   m := metadata.New(a.Files[index])
 
   // info from embedded tags within audio file
@@ -38,7 +32,7 @@ func (a *audioc) processFile(index int) (*metadata.Metadata, error) {
     return m, err
   }
 
-  m.Info, m.Match = m.Info.MatchBestInfo(i,
+  m.Info, m.Match = m.MatchBestInfo(a.InfoFromConfig(index),
     metadata.ProbeTagsToInfo(d.Format.Tags))
 
   // skip if sources match (unless --force)

metadata/metadata.go

@@ -23,11 +23,6 @@ type Info struct {
   Disc, Track, Title string
 }
 
-// Ffprober within context of metadata only needs to implement GetData
-type Ffprober interface {
-  GetData(filePath string) (*ffprobe.Data, error)
-}
-
 // filePath used to derive info
 func New(filePath string) *Metadata {
   var file string
@@ -51,11 +46,63 @@ func New(filePath string) *Metadata {
 
 // build info from ffprobe.Tags
 func ProbeTagsToInfo(p *ffprobe.Tags) *Info {
-  i := &Info{ Artist: p.Artist, Disc: p.Disc,
-    Track: p.Track, Title: p.Title }
+  return &Info{ Artist: p.Artist, Album: p.Album, Disc: p.Disc, Track: p.Track,
+    Title: p.Title }
+}
+
+// compare file & path info against ffprobe.Tags info and combine into best
+// return includes boolean if info sources match (no update necessary)
+func (m *Metadata) MatchBestInfo(c, p *Info) (*Info, bool) {
+  // set custom artist
+  if len(c.Artist) > 0 {
+    m.Info.Artist = c.Artist
+  }
+
+  // set custom album
+  if len(c.Album) > 0 {
+    m.Info.Album = c.matchCleanAlbum(c.Album)
+  }
 
-  i.Album = strings.TrimSpace(i.MatchCleanAlbum(p.Album))
-  return i
+  // compare using safeFilename since info is derived from filename
+  compare := p
+  compare.Album = safeFilename(compare.Album)
+  compare.Title = safeFilename(compare.Title)
+
+  // pull info from album
+  p.Album = p.matchCleanAlbum(p.Album)
+
+  if *m.Info != *compare {
+    if len(m.Info.Artist) == 0 {
+      m.Info.Artist = p.Artist
+    }
+    if len(m.Info.Year) == 0 {
+      m.Info.Year = p.Year
+    }
+    if len(m.Info.Month) == 0 {
+      m.Info.Month = p.Month
+    }
+    if len(m.Info.Day) == 0 {
+      m.Info.Day = p.Day
+    }
+    if len(m.Info.Disc) == 0 {
+      m.Info.Disc = regexp.MustCompile(`^\d+`).FindString(p.Disc)
+    }
+    if len(m.Info.Track) == 0 {
+      m.Info.Track = regexp.MustCompile(`^\d+`).FindString(p.Track)
+    }
+    // take longer album if custom album not set
+    if len(m.Info.Album) == 0 || (len(c.Album) == 0 && len(p.Album) > len(m.Info.Album)) {
+      m.Info.Album = p.Album
+    }
+    // take longer title
+    if len(m.Info.Title) < len(p.Title) {
+      m.Info.Title = p.Title
+    }
+
+    return m.Info, false
+  }
+
+  return m.Info, true
 }
 
 // derive info album info from nested folder path
@@ -66,7 +113,7 @@ func (m *Metadata) fromPath(p string) {
   // start inner-most folder, work out
   foundAlbum := false
   for x := len(sa)-1; x >= 0; x-- {
-    sa[x] = m.Info.MatchCleanAlbum(sa[x])
+    sa[x] = m.Info.matchCleanAlbum(sa[x])
 
     if sa[x] != "" {
       // only overwrite album if not yet set
@@ -103,7 +150,7 @@ func (m *Metadata) fromFile(s string) {
   m.Info.Title = matchAlbumOrTitle(s)
 }
 
-func (i *Info) MatchCleanAlbum(s string) string {
+func (i *Info) matchCleanAlbum(s string) string {
   s = i.matchDiscOnly(s)
   s = i.matchDate(s)
   s = i.matchYearOnly(s)
@@ -143,61 +190,6 @@ func (i *Info) ToFile() string {
   return out + safeFilename(i.Title)
 }
 
-// compare file & path info against ffprobe.Tags info and combine into best
-// return includes boolean if info sources match (no update necessary)
-func (i *Info) MatchBestInfo(c, p *Info) (*Info, bool) {
-  // set custom artist
-  if len(c.Artist) > 0 {
-    i.Artist = c.Artist
-  }
-
-  // set custom album
-  if len(c.Album) > 0 {
-    i.Album = c.Album
-  }
-
-  // compare using safeFilename since info is derived from filename
-  compare := p
-  compare.Album = safeFilename(compare.Album)
-  compare.Title = safeFilename(compare.Title)
-
-  if *i != *compare {
-    // info overrides probe for Artist
-    if len(p.Artist) == 0 || len(c.Artist) > 0 {
-      p.Artist = i.Artist
-    }
-
-    // update Year, Month, Day, Disc, Track if not set
-    if len(p.Year) == 0 {
-      p.Year = i.Year
-    }
-    if len(p.Month) == 0 {
-      p.Month = i.Month
-    }
-    if len(p.Day) == 0 {
-      p.Day = i.Day
-    }
-    if len(p.Disc) == 0 || regexp.MustCompile(`^\d+`).FindString(p.Disc) != p.Disc {
-      p.Disc = i.Disc
-    }
-    if len(p.Track) == 0 {
-      p.Track = i.Track
-    }
-
-    if (len(p.Album) < len(i.Album)) || len(c.Album) > 0 {
-      p.Album = i.Album
-    }
-
-    if len(p.Title) < len(i.Title) {
-      p.Title = i.Title
-    }
-
-    return p, false
-  }
-
-  return i, true
-}
-
 // converts roman numeral to int; only needs to support up to 5
 var romanNumeralMap = map[string]string{
   "I": "1", "II": "2", "III": "3", "IV": "4", "V": "5",

metadata/metadata_test.go

@@ -51,34 +51,35 @@ func TestToFile(t *testing.T) {
 
 func TestMatchProbeInfo(t *testing.T) {
   tests := []struct {
-    info, comb *Info
+    m *Metadata
+    comb *Info
     tags *ffprobe.Tags
     match bool
   }{
-    { info: &Info{ Album: "Kean College After Midnight", Title: "After Midnight" },
+    { m: &Metadata{Info: &Info{ Album: "Kean College After Midnight", Title: "After Midnight" }},
       tags: &ffprobe.Tags{ Album: "Something Else" },
       comb: &Info{ Album: "Kean College After Midnight", Title: "After Midnight" },
       match: false,
     },{
-      info: &Info{ Album: "Kean College After Midnight", Year: "1980" },
+      m: &Metadata{Info: &Info{ Album: "Kean College After Midnight", Year: "1980" }},
       tags: &ffprobe.Tags{ Album: "1980 Kean College After Midnight" },
       comb: &Info{ Album: "Kean College After Midnight", Year: "1980" },
       match: true,
     },{
-      info: &Info{ Album: "Kean College After Midnight", Year: "1980" },
+      m: &Metadata{Info: &Info{ Album: "Kean College After Midnight", Year: "1980" }},
       tags: &ffprobe.Tags{ Album: "1980.02.28 Kean College After Midnight" },
       comb: &Info{ Album: "Kean College After Midnight", Year: "1980", Month: "02", Day: "28" },
       match: false,
     },{
-      info: &Info{ Disc: "1" },
+      m: &Metadata{Info: &Info{ Disc: "1" }},
       tags: &ffprobe.Tags{ Disc: "1/2" },
       comb: &Info{ Disc: "1" },
       match: false,
     },
   }
 
   for x := range tests {
-    rInfo, match := tests[x].info.MatchBestInfo(&Info{},
+    rInfo, match := tests[x].m.MatchBestInfo(&Info{},
       ProbeTagsToInfo(tests[x].tags))
 
     if *rInfo != *tests[x].comb {