refactor: simplify codebase (-209 lines)

internal/provider/genre.go

@@ -9,48 +9,50 @@ import (
 	"github.com/PuerkitoBio/goquery"
 )
 
-var electronicKeywords = []string{
+var electronicKeywords = toLower([]string{
 	"Ambient", "Bass", "Big Room", "Breakbeat", "Dance", "Disco", "Downtempo",
 	"Drum And Bass", "Dub", "Dubstep", "EDM", "Electro", "Electronic", "Electronica",
 	"Eurodance", "Gabber", "Garage", "Hardcore", "Hardstyle", "House", "Industrial",
 	"Jungle", "Moombahton", "Synthpop", "Synthwave", "Techno", "Trance", "Trap",
 	"Trip Hop", "Vaporwave",
-}
+})
 
-var nonElectronicKeywords = []string{
+var nonElectronicKeywords = toLower([]string{
 	"Blues", "Chillout", "Classical", "Country", "Folk", "Funk", "Hip Hop", "Jazz",
 	"Latin", "Metal", "Pop", "R&B", "Rap", "Reggae", "Rock", "Soul",
+})
+
+func toLower(ss []string) []string {
+	out := make([]string, len(ss))
+	for i, s := range ss {
+		out[i] = strings.ToLower(s)
+	}
+	return out
 }
 
-type GenreProvider struct{}
+func FetchGenre(ctx context.Context, httpClient *http.Client, artist, title string) (string, error) {
+	reqURL := fmt.Sprintf("https://www.last.fm/music/%s/%s/+tags", artist, title)
 
-func (p GenreProvider) Fetch(ctx context.Context, httpClient *http.Client, artist, title string) (string, error) {
-	reqUrl := fmt.Sprintf("https://www.last.fm/music/%s/%s/+tags", artist, title)
-	doc, err := p.fetchPage(ctx, httpClient, reqUrl)
+	doc, err := fetchGenrePage(ctx, httpClient, reqURL)
 	if err != nil {
 		return "", err
 	}
 
-	tags := p.parse(doc)
-	if len(tags) == 0 {
-		return "", fmt.Errorf("no data found")
-	}
-
+	tags := parseGenreTags(doc)
 	if len(tags) > 2 {
 		tags = tags[:2]
 	}
 
-	filteredTags := p.filterTags(tags)
-	if len(filteredTags) == 0 {
+	filtered := filterTags(tags)
+	if len(filtered) == 0 {
 		return "", fmt.Errorf("no data found")
 	}
 
-	genre := p.formatTags(filteredTags)
-	return genre, nil
+	return formatTags(filtered), nil
 }
 
-func (p GenreProvider) fetchPage(ctx context.Context, httpClient *http.Client, reqUrl string) (*goquery.Document, error) {
-	req, err := http.NewRequestWithContext(ctx, "GET", reqUrl, nil)
+func fetchGenrePage(ctx context.Context, httpClient *http.Client, url string) (*goquery.Document, error) {
+	req, err := http.NewRequestWithContext(ctx, "GET", url, nil)
 	if err != nil {
 		return nil, err
 	}
@@ -65,84 +67,58 @@ func (p GenreProvider) fetchPage(ctx context.Context, httpClient *http.Client, r
 		return nil, fmt.Errorf("unexpected status code: %d", resp.StatusCode)
 	}
 
-	doc, err := goquery.NewDocumentFromReader(resp.Body)
-	if err != nil {
-		return nil, err
-	}
-
-	return doc, nil
+	return goquery.NewDocumentFromReader(resp.Body)
 }
 
-func (p GenreProvider) parse(doc *goquery.Document) []string {
+func parseGenreTags(doc *goquery.Document) []string {
 	var tags []string
 	doc.Find("ol.big-tags .big-tags-item-name a").Each(func(_ int, s *goquery.Selection) {
-		tag := strings.TrimSpace(s.Text())
-		if tag != "" {
+		if tag := strings.TrimSpace(s.Text()); tag != "" {
 			tags = append(tags, tag)
 		}
 	})
-
 	return tags
 }
 
-func (p GenreProvider) filterTags(tags []string) []string {
-	var electronicTags []string
-	var nonElectronicTags []string
+func matchesKeyword(tag string, keywords []string) bool {
+	tagLower := strings.ToLower(tag)
+	for _, kw := range keywords {
+		if strings.Contains(tagLower, kw) {
+			return true
+		}
+	}
+	return false
+}
+
+func filterTags(tags []string) []string {
+	var electronic, nonElectronic []string
 
 	for _, tag := range tags {
-		if p.isElectronicGenre(tag) {
-			electronicTags = append(electronicTags, tag)
-		} else if p.isNonElectronicGenre(tag) {
-			nonElectronicTags = append(nonElectronicTags, tag)
+		if matchesKeyword(tag, electronicKeywords) {
+			electronic = append(electronic, tag)
+		} else if matchesKeyword(tag, nonElectronicKeywords) {
+			nonElectronic = append(nonElectronic, tag)
 		}
 	}
 
-	var filteredTags []string
-	filteredTags = append(filteredTags, electronicTags...)
-
-	if len(electronicTags) > 0 {
-		filteredTags = append(filteredTags, nonElectronicTags...)
+	if len(electronic) > 0 {
+		return append(electronic, nonElectronic...)
 	}
-
-	return filteredTags
+	return electronic
 }
 
-func (p GenreProvider) isElectronicGenre(tag string) bool {
-	tagLower := strings.ToLower(tag)
-	for _, allowed := range electronicKeywords {
-		if strings.Contains(tagLower, strings.ToLower(allowed)) {
-			return true
-		}
-	}
-	return false
-}
-
-func (p GenreProvider) isNonElectronicGenre(tag string) bool {
-	tagLower := strings.ToLower(tag)
-	for _, allowed := range nonElectronicKeywords {
-		if strings.Contains(tagLower, strings.ToLower(allowed)) {
-			return true
-		}
-	}
-	return false
-}
-
-func (p GenreProvider) formatTags(tags []string) string {
-	var formatted []string
+func formatTags(tags []string) string {
+	formatted := make([]string, 0, len(tags))
 	for _, tag := range tags {
 		tag = strings.TrimSpace(tag)
 		if tag == "" {
 			continue
 		}
-
 		words := strings.Fields(tag)
 		for i, w := range words {
-			if len(w) > 0 {
-				words[i] = strings.ToUpper(string(w[0])) + strings.ToLower(w[1:])
-			}
+			words[i] = strings.ToUpper(w[:1]) + strings.ToLower(w[1:])
 		}
 		formatted = append(formatted, strings.Join(words, " "))
 	}
-
 	return strings.Join(formatted, " / ")
 }