From 5fb195f0d686cadd136ef89512c73065dc86d235 Mon Sep 17 00:00:00 2001 From: Chris Date: Tue, 29 Sep 2026 14:58:36 -0700 Subject: [PATCH] Redo file naming in the style of Lidarr and add "Rename now" Naming: separate artist folder, album folder, track and multi-disc track formats with presets, Lidarr-style tokens ({Artist Name}, {Artist NameThe}, {Artist CleanName}, {Artist NameFirstCharacter}, {Album Title}, {Album TitleThe}, {Album CleanTitle}, {Release Year}, {track:00}, {medium:00}, {Medium Format}, {Track Title}, {Track CleanTitle}, {Track ArtistName}, {Genre}) with Lidarr's word-separator and case variants, colon replacement modes and replace/remove for other illegal characters. Empty brackets and separators left by missing values are cleaned up. Defaults to Artist/Album/01 Title with Disc 01 folders for multi-disc albums; earlier pattern/disc settings are converted. Examples are now rendered by the server with the same code as real renames, fixing the settings page showing paths that differed from what would happen (e.g. disc 1 of a multi-disc album outside its Disc folder). "Rename now..." checks one or both libraries, then lists every change grouped by destination folder with per-file and per-folder selection, skipped files with reasons and a Fix tags button, and warnings; applying re-checks each file, renames, and rescans. The pre-action backup runs first when enabled. Migration 9 stores the naming as JSON. Co-Authored-By: Claude Opus 5.5 --- README.md | 25 +- internal/api/server.go | 89 +++++- internal/engine/engine.go | 3 + internal/engine/naming.go | 476 ++++++++++++++++++++++++++++++ internal/engine/naming_test.go | 156 ++++++++++ internal/engine/organize.go | 284 ++++++++---------- internal/engine/organize_test.go | 41 --- internal/store/models.go | 60 ++-- internal/store/store.go | 3 + web/src/api.ts | 20 +- web/src/pages/Organize.tsx | 487 +++++++++++++++++++++++++------ web/src/pages/PairForm.tsx | 8 +- 12 files changed, 1297 insertions(+), 355 deletions(-) create mode 100644 internal/engine/naming.go create mode 100644 internal/engine/naming_test.go diff --git a/README.md b/README.md index 5982e10..cb0c682 100644 --- a/README.md +++ b/README.md @@ -83,16 +83,23 @@ tags** buttons. Edits are safe with hardlinks: - Each edit is listed in History (old → new values) and can be undone; an in-place edit interrupted by a crash is rolled back on startup. Dry run applies. -**Organize (rename files from tags).** The *Organize* tab sets a naming layout, by default `{artist}/{album}/{track} {title}` → -`Avenged Sevenfold/Nightmare/01 Nightmare.flac` (`{artist}` is the album artist, falling back to the artist). Tokens: `{artist}`, -`{album}`, `{track}`, `{title}`, `{year}`, `{disc}`, `{track_artist}`, `{genre}`. Multi-disc albums get a disc prefix (`2-04 Title`) or -a `Disc 02` folder (two-digit disc numbers by default, optionally `Disc 2`), and names are made safe for Windows/SMB shares (`AC/DC` → `AC-DC`, `Title: Sub` → `Title - Sub`). +**Organize (rename files from tags).** The *Organize* tab sets how files are named, in the style of Lidarr: an **artist folder**, an +**album folder**, a **track format** and a separate **multi-disc track format**, with presets. The default is +`{Artist Name}/{Album Title}/{track:00} {Track Title}`, and multi-disc albums get `{Medium Format} {medium:00}/…` → `Disc 01`, `Disc 02`. -With **Organize automatically** set to the slave, the master or both (off by default), every scan renames files that don't follow the -layout. Files are only moved within their library, so contents and hardlinks never change; lyrics (`.lrc`) move with their song, cover -art follows a whole folder, and emptied folders are removed. Files with missing tags or clashing names are left alone (fix their tags -in the *Tags* tab). Each rename is in History and can be undone, and dry run applies. A slave file that is a hardlink of a master file -at a different path is still recognised as linked. +Tokens: `{Artist Name}`, `{Artist NameThe}` (The Beatles → Beatles, The), `{Artist CleanName}`, `{Artist NameFirstCharacter}`, +`{Album Title}`, `{Album TitleThe}`, `{Album CleanTitle}`, `{Release Year}`, `{track:0}`/`{track:00}`, `{medium:0}`/`{medium:00}`, +`{Medium Format}`, `{Track Title}`, `{Track CleanTitle}`, `{Track ArtistName}`, `{Genre}`. Like Lidarr, `{Artist.Name}` or `{Artist_Name}` +puts dots or underscores between words and `{ARTIST NAME}` / `{artist name}` change the case. The artist is the album artist, falling back +to the artist. Colons can be replaced smartly (`A: B` → `A - B`), with a dash, space dash, space dash space, or deleted; other characters +Windows/SMB rejects are replaced (`AC/DC` → `AC-DC`) or removed. Brackets and separators left empty by a missing value are cleaned up +(`Album ({Release Year})` without a year → `Album`). Examples are rendered by the same code that renames files. + +**Rename now…** checks the slave, the master or both, then shows every change grouped by destination folder (old → new, selectable per +file or folder), plus skipped files with the reason and a *Fix tags* button. Files are only moved within their library, so contents and +hardlinks never change; lyrics (`.lrc`) move with their song, cover art follows a whole folder, and emptied folders are removed. Each +rename is in History and can be undone, and the library is rescanned afterwards. **Organize automatically** (off by default) applies the +same renames during every scan. A slave file that is a hardlink of a master file at a different path is still recognised as linked. **Backups** (Settings → Backups), similar to Sonarr. A backup is a zip of playlink's database (settings, library pairs, scan results and history, not music files) taken safely while the app runs. Choose a folder (default `/config/backups`), a schedule (off, every 1, 3, 7 diff --git a/internal/api/server.go b/internal/api/server.go index a1ab149..25d02d7 100644 --- a/internal/api/server.go +++ b/internal/api/server.go @@ -79,6 +79,8 @@ func (s *Server) Handler() http.Handler { r.Get("/settings", s.handleGetSettings) r.Put("/settings", s.handlePutSettings) r.Get("/browse", s.handleBrowse) + r.Get("/naming", s.handleNamingInfo) + r.Post("/naming/examples", s.handleNamingExamples) if s.cfg.Backups != nil { s.backupRoutes(r) } @@ -101,6 +103,9 @@ func (s *Server) Handler() http.Handler { r.Get("/files", s.handleFiles) r.Post("/tags/read", s.handleReadTags) r.Post("/tags", s.handleEditTags) + r.Post("/organize/preview", s.handleOrganizePreview) + r.Get("/organize/plan", s.handleOrganizePlan) + r.Post("/organize/apply", s.handleOrganizeApply) r.Get("/renames", s.handleRenamePreview) r.Post("/renames", s.handleRenames) r.Post("/link-identical", s.handleLinkIdentical) @@ -303,13 +308,14 @@ func (s *Server) handleBrowse(w http.ResponseWriter, r *http.Request) { type pairView struct { store.Pair - Summary store.Summary `json:"summary"` - Job *engine.Job `json:"job"` + Naming engine.NamingConfig `json:"naming"` + Summary store.Summary `json:"summary"` + Job *engine.Job `json:"job"` } func (s *Server) view(r *http.Request, p store.Pair) pairView { sum, _ := s.st.Summary(r.Context(), p.ID) - return pairView{Pair: p, Summary: sum, Job: s.eng.Job(p.ID)} + return pairView{Pair: p, Naming: engine.NamingOf(p), Summary: sum, Job: s.eng.Job(p.ID)} } func (s *Server) handleListPairs(w http.ResponseWriter, r *http.Request) { @@ -347,10 +353,9 @@ type pairInput struct { SettleMinutes int `json:"settle_minutes"` ApproxMatching bool `json:"approx_matching"` ApproxThreshold int `json:"approx_threshold"` - OrganizeTemplate string `json:"organize_template"` - OrganizeMultiDisc string `json:"organize_multidisc"` AutoOrganize string `json:"auto_organize"` - OrganizeDiscDigits int `json:"organize_disc_digits"` + // Naming is optional: when absent, the pair keeps its current naming. + Naming *engine.NamingConfig `json:"naming,omitempty"` } func (in pairInput) apply(p *store.Pair) { @@ -358,8 +363,10 @@ func (in pairInput) apply(p *store.Pair) { p.Extensions, p.AutoLinkIdentical = in.Extensions, in.AutoLinkIdentical p.ScanIntervalMinutes, p.RetentionDays, p.SettleMinutes = in.ScanIntervalMinutes, in.RetentionDays, in.SettleMinutes p.ApproxMatching, p.ApproxThreshold = in.ApproxMatching, in.ApproxThreshold - p.OrganizeTemplate, p.OrganizeMultiDisc, p.AutoOrganize = in.OrganizeTemplate, in.OrganizeMultiDisc, in.AutoOrganize - p.OrganizeDiscDigits = in.OrganizeDiscDigits + p.AutoOrganize = in.AutoOrganize + if in.Naming != nil { + p.OrganizeConfig, _ = json.Marshal(in.Naming) + } } func (s *Server) handleValidatePair(w http.ResponseWriter, r *http.Request) { @@ -800,3 +807,69 @@ func (s *Server) preAction(w http.ResponseWriter, r *http.Request, pairID int64, } return true } + +// ---- organizer ---- + +func (s *Server) handleNamingInfo(w http.ResponseWriter, r *http.Request) { + writeJSON(w, 200, map[string]any{"defaults": engine.DefaultNaming(), "presets": engine.NamingPresets, "tokens": engine.TokenHelp}) +} + +// handleNamingExamples renders sample songs with unsaved settings, using the +// same code as real renames. +func (s *Server) handleNamingExamples(w http.ResponseWriter, r *http.Request) { + var c engine.NamingConfig + if !readJSON(w, r, &c) { + return + } + if err := engine.ValidateNaming(c); err != nil { + writeJSON(w, 200, map[string]any{"error": err.Error(), "examples": []engine.NamingExample{}}) + return + } + writeJSON(w, 200, map[string]any{"examples": engine.NamingExamples(c)}) +} + +func (s *Server) handleOrganizePreview(w http.ResponseWriter, r *http.Request) { + id, _ := idParam(r) + var body struct { + Side string `json:"side"` // slave, master or both + } + if !readJSON(w, r, &body) { + return + } + j, err := s.eng.StartOrganizePreview(id, body.Side) + if err != nil { + opErr(w, err) + return + } + writeJSON(w, 202, j) +} + +func (s *Server) handleOrganizePlan(w http.ResponseWriter, r *http.Request) { + id, _ := idParam(r) + plan, items := s.eng.OrganizePreview(id) + if plan == nil { + writeJSON(w, 200, map[string]any{"plan": nil, "items": []any{}}) + return + } + writeJSON(w, 200, map[string]any{"plan": plan, "items": items}) +} + +func (s *Server) handleOrganizeApply(w http.ResponseWriter, r *http.Request) { + id, _ := idParam(r) + var body struct { + IDs []int `json:"ids"` // empty: every rename in the preview + } + if !readJSON(w, r, &body) { + return + } + if !s.preAction(w, r, id, "rename files") { + return + } + j, err := s.eng.StartOrganizeApply(id, body.IDs) + if err != nil { + opErr(w, err) + return + } + s.log.Info("rename now started", "pair", id, "selected", len(body.IDs)) + writeJSON(w, 202, j) +} diff --git a/internal/engine/engine.go b/internal/engine/engine.go index b3a5895..703fd90 100644 --- a/internal/engine/engine.go +++ b/internal/engine/engine.go @@ -46,6 +46,9 @@ type Engine struct { beforeAction func(ctx context.Context, reason string) error tagCache tagCache + plansMu sync.Mutex + plans map[int64]*organizePlan // latest "rename now" preview per pair + jobsMu sync.Mutex jobs map[int64]*Job nextID int64 diff --git a/internal/engine/naming.go b/internal/engine/naming.go new file mode 100644 index 0000000..2fbe28c --- /dev/null +++ b/internal/engine/naming.go @@ -0,0 +1,476 @@ +package engine + +import ( + "encoding/json" + "errors" + "fmt" + "path/filepath" + "regexp" + "strings" + "unicode" + "unicode/utf8" + + "github.com/cdnutter/playlink/internal/store" + "github.com/cdnutter/playlink/internal/tags" +) + +// Naming follows Lidarr's model: an artist folder, an album folder and a +// track format (with a separate format for multi-disc albums), built from +// tokens such as {Artist Name}, {Album Title} and {track:00}. + +type NamingConfig struct { + ArtistFolder string `json:"artist_folder"` + AlbumFolder string `json:"album_folder"` + TrackFormat string `json:"track_format"` + MultiDiscFormat string `json:"multi_disc_format"` + Colon string `json:"colon"` // smart, delete, dash, space_dash, space_dash_space + Illegal string `json:"illegal"` // replace or remove +} + +func DefaultNaming() NamingConfig { + return NamingConfig{ + ArtistFolder: "{Artist Name}", + AlbumFolder: "{Album Title}", + TrackFormat: "{track:00} {Track Title}", + MultiDiscFormat: "{Medium Format} {medium:00}/{track:00} {Track Title}", + Colon: "smart", + Illegal: "replace", + } +} + +// NamingPresets are offered in the UI. +var NamingPresets = []struct { + Name string `json:"name"` + Config NamingConfig `json:"config"` +}{ + {"Artist/Album/01 Title", DefaultNaming()}, + {"Artist/Album (Year)/01 - Title", NamingConfig{ArtistFolder: "{Artist Name}", AlbumFolder: "{Album Title} ({Release Year})", + TrackFormat: "{track:00} - {Track Title}", MultiDiscFormat: "{Medium Format} {medium:00}/{track:00} - {Track Title}", Colon: "smart", Illegal: "replace"}}, + {"Artist/Album/Artist - Album - 01 - Title", NamingConfig{ArtistFolder: "{Artist Name}", AlbumFolder: "{Album Title}", + TrackFormat: "{Artist Name} - {Album Title} - {track:00} - {Track Title}", + MultiDiscFormat: "{Artist Name} - {Album Title} - {medium:00}-{track:00} - {Track Title}", Colon: "smart", Illegal: "replace"}}, + {"Artist/Album/1-01 Title (disc in name)", NamingConfig{ArtistFolder: "{Artist Name}", AlbumFolder: "{Album Title}", + TrackFormat: "{track:00} {Track Title}", MultiDiscFormat: "{medium:0}-{track:00} {Track Title}", Colon: "smart", Illegal: "replace"}}, +} + +// NamingOf returns a pair's naming, converting the settings of earlier +// versions (one path pattern plus a disc style) when none is stored yet. +func NamingOf(p store.Pair) NamingConfig { + c := DefaultNaming() + if len(p.OrganizeConfig) > 0 && string(p.OrganizeConfig) != "{}" { + var stored NamingConfig + if json.Unmarshal(p.OrganizeConfig, &stored) == nil { + fill(&stored, c) + return stored + } + } + old := map[string]string{"{artist}": "{Artist Name}", "{album}": "{Album Title}", "{track}": "{track:00}", "{title}": "{Track Title}", + "{year}": "{Release Year}", "{track_artist}": "{Track ArtistName}", "{genre}": "{Genre}"} + medium := "{medium:00}" + if p.OrganizeDiscDigits == 1 { + medium = "{medium:0}" + } + old["{disc}"] = medium + if parts := strings.Split(p.OrganizeTemplate, "/"); len(parts) == 3 { + conv := func(s string) string { + for k, v := range old { + s = strings.ReplaceAll(s, k, v) + } + return s + } + c.ArtistFolder, c.AlbumFolder, c.TrackFormat = conv(parts[0]), conv(parts[1]), conv(parts[2]) + } + switch p.OrganizeMultiDisc { + case "prefix": + c.MultiDiscFormat = strings.Replace(c.TrackFormat, "{track:00}", medium+"-{track:00}", 1) + case "none": + c.MultiDiscFormat = c.TrackFormat + default: + c.MultiDiscFormat = "{Medium Format} " + medium + "/" + c.TrackFormat + } + return c +} + +func fill(c *NamingConfig, d NamingConfig) { + if strings.TrimSpace(c.ArtistFolder) == "" { + c.ArtistFolder = d.ArtistFolder + } + if strings.TrimSpace(c.AlbumFolder) == "" { + c.AlbumFolder = d.AlbumFolder + } + if strings.TrimSpace(c.TrackFormat) == "" { + c.TrackFormat = d.TrackFormat + } + if strings.TrimSpace(c.MultiDiscFormat) == "" { + c.MultiDiscFormat = d.MultiDiscFormat + } + if c.Colon == "" { + c.Colon = d.Colon + } + if c.Illegal == "" { + c.Illegal = d.Illegal + } +} + +// ---- tokens ---- + +var ( + tokenPat = regexp.MustCompile(`\{([^{}]+)\}`) + numberTok = regexp.MustCompile(`(?i)^(track|medium):(0+)$`) +) + +// TokenHelp documents the tokens (with example values) for the UI. +var TokenHelp = [][2]string{ + {"{Artist Name}", "Avenged Sevenfold"}, {"{Artist NameThe}", "Beatles, The"}, {"{Artist CleanName}", "ACDC"}, + {"{Artist NameFirstCharacter}", "A"}, {"{Album Title}", "Nightmare"}, {"{Album TitleThe}", "White Album, The"}, + {"{Album CleanTitle}", "Nightmare"}, {"{Release Year}", "2010"}, {"{track:00}", "01"}, {"{track:0}", "1"}, + {"{medium:00}", "01"}, {"{medium:0}", "1"}, {"{Medium Format}", "Disc"}, {"{Track Title}", "Nightmare"}, + {"{Track CleanTitle}", "Nightmare"}, {"{Track ArtistName}", "Avenged Sevenfold"}, {"{Genre}", "Metal"}, +} + +var knownTokens = map[string]bool{ + "artistname": true, "artistnamethe": true, "artistcleanname": true, "artistnamefirstcharacter": true, + "albumtitle": true, "albumtitlethe": true, "albumcleantitle": true, "releaseyear": true, + "tracktitle": true, "trackcleantitle": true, "trackartistname": true, "mediumformat": true, "genre": true, +} + +// tokenKey normalizes "Artist Name", "Artist.Name" and "ARTIST_NAME". +func tokenKey(t string) string { + var b strings.Builder + for _, r := range strings.ToLower(t) { + if unicode.IsLetter(r) || unicode.IsDigit(r) { + b.WriteRune(r) + } + } + return b.String() +} + +// styleOf returns the word separator and case a token is written in. +func styleOf(t string) (sep string, cased string) { + sep = " " + switch { + case strings.Contains(t, "."): + sep = "." + case strings.Contains(t, "_"): + sep = "_" + } + letters := strings.Map(func(r rune) rune { + if unicode.IsLetter(r) { + return r + } + return -1 + }, t) + switch { + case letters != "" && letters == strings.ToUpper(letters): + cased = "upper" + case letters != "" && letters == strings.ToLower(letters): + cased = "lower" + } + return +} + +// ValidateNaming checks the formats. +func ValidateNaming(c NamingConfig) error { + check := func(label, f string, folder bool) error { + if strings.TrimSpace(f) == "" { + return fmt.Errorf("%s is empty", label) + } + if strings.Contains(f, "..") || strings.Contains(f, "\\") || strings.HasPrefix(f, "/") || strings.HasSuffix(f, "/") { + return fmt.Errorf("%s must be a relative name without .. or backslashes", label) + } + if folder && strings.Contains(f, "/") { + return fmt.Errorf("%s must be a single folder name (no /)", label) + } + for _, m := range tokenPat.FindAllStringSubmatch(f, -1) { + if numberTok.MatchString(m[1]) { + continue + } + if !knownTokens[tokenKey(m[1])] { + return fmt.Errorf("%s: unknown token {%s}", label, m[1]) + } + } + if strings.Count(f, "{") != strings.Count(f, "}") { + return fmt.Errorf("%s has an unclosed {", label) + } + return nil + } + if err := check("Artist folder format", c.ArtistFolder, true); err != nil { + return err + } + if err := check("Album folder format", c.AlbumFolder, true); err != nil { + return err + } + for _, f := range []struct{ label, v string }{{"Track format", c.TrackFormat}, {"Multi-disc track format", c.MultiDiscFormat}} { + if err := check(f.label, f.v, false); err != nil { + return err + } + if !strings.Contains(tokenKeys(f.v), "|tracktitle|") && !strings.Contains(tokenKeys(f.v), "|trackcleantitle|") { + return fmt.Errorf("%s must contain {Track Title}", f.label) + } + } + switch c.Colon { + case "smart", "delete", "dash", "space_dash", "space_dash_space": + default: + return errors.New("unknown colon replacement") + } + if c.Illegal != "replace" && c.Illegal != "remove" { + return errors.New("illegal characters must be replace or remove") + } + return nil +} + +func tokenKeys(f string) string { + var b strings.Builder + b.WriteString("|") + for _, m := range tokenPat.FindAllStringSubmatch(f, -1) { + b.WriteString(tokenKey(m[1]) + "|") + } + return b.String() +} + +// ---- value transforms ---- + +var articles = []string{"The ", "A ", "An "} + +// nameThe moves a leading article to the end: "The Beatles" -> "Beatles, The". +func nameThe(s string) string { + for _, a := range articles { + if len(s) > len(a) && strings.EqualFold(s[:len(a)], a) { + return strings.TrimSpace(s[len(a):]) + ", " + strings.TrimSpace(s[:len(a)]) + } + } + return s +} + +// cleanName keeps letters, digits and spaces: "AC/DC" -> "ACDC". +func cleanName(s string) string { + s = strings.Map(func(r rune) rune { + switch { + case unicode.IsLetter(r), unicode.IsDigit(r), r == ' ': + return r + case r == '&': + return r + } + return -1 + }, s) + return strings.TrimSpace(spaces.ReplaceAllString(s, " ")) +} + +func firstChar(s string) string { + for _, r := range nameThe(s) { + if unicode.IsLetter(r) { + return string(unicode.ToUpper(r)) + } + if unicode.IsDigit(r) { + return "#" + } + } + return "" +} + +func colonReplace(s, mode string) string { + switch mode { + case "delete": + return strings.ReplaceAll(s, ":", "") + case "dash": + return strings.ReplaceAll(s, ":", "-") + case "space_dash": + return strings.ReplaceAll(s, ":", " -") + case "space_dash_space": + return strings.ReplaceAll(strings.ReplaceAll(s, " :", ":"), ":", " - ") + } + // smart: "Title: Sub" -> "Title - Sub", "10:30" -> "10-30" + s = strings.ReplaceAll(s, ": ", " - ") + return strings.ReplaceAll(s, ":", "-") +} + +var ( + illegalReplace = strings.NewReplacer("/", "-", "\\", "-", "|", "-", "*", "-", "?", "", "\"", "'", "<", "", ">", "") + illegalRemove = strings.NewReplacer("/", "", "\\", "", "|", "", "*", "", "?", "", "\"", "", "<", "", ">", "") +) + +// safeValue makes a tag value safe inside a file or folder name. +func safeValue(s string, c NamingConfig) string { + s = colonReplace(s, c.Colon) + if c.Illegal == "remove" { + s = illegalRemove.Replace(s) + } else { + s = illegalReplace.Replace(s) + } + return strings.Map(func(r rune) rune { + if unicode.IsControl(r) { + return -1 + } + return r + }, s) +} + +var emptyBrackets = regexp.MustCompile(`\(\s*\)|\[\s*\]|\{\s*\}`) + +// finishComponent tidies a rendered name: empty brackets and separators left +// by missing optional values are removed, and leading dots (hidden files) +// and trailing dots/spaces (invalid on Windows) are trimmed. +func finishComponent(s string) string { + s = emptyBrackets.ReplaceAllString(s, "") + s = spaces.ReplaceAllString(s, " ") + for _, dup := range []string{" - - ", " - - "} { + for strings.Contains(s, dup) { + s = strings.ReplaceAll(s, dup, " - ") + } + } + s = strings.Trim(s, " -._") + s = strings.TrimLeft(s, ".") + for len(s) > maxComponent { + _, size := utf8.DecodeLastRuneInString(s) + s = strings.TrimRight(s[:len(s)-size], ". ") + } + return s +} + +// songValues are the raw values tokens draw from. +type songValues struct { + artist, trackArtist, album, title, year, genre string + track, disc, discTotal int +} + +func valuesOf(f map[string]string) songValues { + v := songValues{ + artist: strings.TrimSpace(f[tags.AlbumArtist]), trackArtist: strings.TrimSpace(f[tags.Artist]), + album: strings.TrimSpace(f[tags.Album]), title: strings.TrimSpace(f[tags.Title]), genre: strings.TrimSpace(f[tags.Genre]), + track: leadingNumber(f[tags.Track]), disc: leadingNumber(f[tags.Disc]), discTotal: leadingNumber(f[tags.DiscTotal]), + } + if v.artist == "" { + v.artist = v.trackArtist + } + if d := strings.TrimSpace(f[tags.Date]); len(d) >= 4 && leadingNumber(d[:4]) > 0 { + v.year = d[:4] + } + return v +} + +func (v songValues) multiDisc() bool { return v.discTotal > 1 || v.disc > 1 } + +// renderPath builds the organized relative path of a song. It returns the +// missing tag when a required one is empty. +func renderPath(c NamingConfig, ext string, f map[string]string) (string, string) { + v := valuesOf(f) + if v.artist == "" { + return "", "artist or album artist" + } + if v.album == "" { + return "", "album" + } + if v.title == "" { + return "", "title" + } + track := c.TrackFormat + if v.multiDisc() { + track = c.MultiDiscFormat + } + var parts []string + for _, f := range []string{c.ArtistFolder, c.AlbumFolder, track} { + for _, part := range strings.Split(f, "/") { + out := tokenPat.ReplaceAllStringFunc(part, func(tok string) string { return renderToken(tok[1:len(tok)-1], v, c) }) + out = finishComponent(out) + if out == "" { + return "", "tags for " + part + } + parts = append(parts, out) + } + } + return filepath.Join(parts...) + strings.ToLower(ext), "" +} + +func renderToken(t string, v songValues, c NamingConfig) string { + if m := numberTok.FindStringSubmatch(t); m != nil { + n := v.track + if strings.EqualFold(m[1], "medium") { + n = v.disc + if n == 0 { + n = 1 + } + } + if n <= 0 { + return "" + } + width := len(m[2]) + if strings.EqualFold(m[1], "track") && n >= 100 && width < 3 { + width = 3 + } + return fmt.Sprintf("%0*d", width, n) + } + var val string + switch tokenKey(t) { + case "artistname": + val = v.artist + case "artistnamethe": + val = nameThe(v.artist) + case "artistcleanname": + val = cleanName(v.artist) + case "artistnamefirstcharacter": + val = firstChar(v.artist) + case "albumtitle": + val = v.album + case "albumtitlethe": + val = nameThe(v.album) + case "albumcleantitle": + val = cleanName(v.album) + case "releaseyear": + val = v.year + case "tracktitle": + val = v.title + case "trackcleantitle": + val = cleanName(v.title) + case "trackartistname": + val = v.trackArtist + case "mediumformat": + val = "Disc" + case "genre": + val = v.genre + } + val = safeValue(val, c) + sep, cased := styleOf(t) + if sep != " " { + val = strings.ReplaceAll(val, " ", sep) + } + switch cased { + case "upper": + val = strings.ToUpper(val) + case "lower": + val = strings.ToLower(val) + } + return val +} + +// NamingExample is one sample rendering for the settings page. +type NamingExample struct { + Label string `json:"label"` + Path string `json:"path"` +} + +// NamingExamples renders sample songs with a naming config, using exactly +// the code that renames real files. +func NamingExamples(c NamingConfig) []NamingExample { + samples := []struct { + label, ext string + f map[string]string + }{ + {"Album track", ".flac", map[string]string{tags.Artist: "Avenged Sevenfold", tags.Album: "Nightmare", tags.Title: "Nightmare", + tags.Track: "1", tags.Date: "2010", tags.Genre: "Metal"}}, + {"Multi-disc album, disc 1", ".flac", map[string]string{tags.Artist: "The Beatles", tags.Album: "The Beatles (White Album)", + tags.Title: "Back in the U.S.S.R.", tags.Track: "1", tags.Disc: "1", tags.DiscTotal: "2", tags.Date: "1968"}}, + {"Multi-disc album, disc 2", ".flac", map[string]string{tags.Artist: "The Beatles", tags.Album: "The Beatles (White Album)", + tags.Title: "Birthday", tags.Track: "1", tags.Disc: "2", tags.DiscTotal: "2", tags.Date: "1968"}}, + {"Colon and slash in names", ".mp3", map[string]string{tags.Artist: "AC/DC", tags.Album: "Who Made Who", tags.Title: "Hells Bells: Live", + tags.Track: "7", tags.Date: "1986"}}, + } + out := []NamingExample{} + for _, s := range samples { + p, missing := renderPath(c, s.ext, s.f) + if missing != "" { + p = "(skipped: missing " + missing + ")" + } + out = append(out, NamingExample{Label: s.label, Path: p}) + } + return out +} diff --git a/internal/engine/naming_test.go b/internal/engine/naming_test.go new file mode 100644 index 0000000..6e926a9 --- /dev/null +++ b/internal/engine/naming_test.go @@ -0,0 +1,156 @@ +package engine + +import ( + "encoding/json" + "os" + "path/filepath" + "testing" + + "github.com/cdnutter/playlink/internal/store" +) + +func song(kv ...string) map[string]string { + m := map[string]string{} + for i := 0; i < len(kv); i += 2 { + m[kv[i]] = kv[i+1] + } + return m +} + +func TestRenderPath(t *testing.T) { + d := DefaultNaming() + with := func(mod func(*NamingConfig)) NamingConfig { c := DefaultNaming(); mod(&c); return c } + nightmare := song("artist", "Avenged Sevenfold", "album", "Nightmare", "title", "Nightmare", "track", "1", "date", "2010-07-27") + cases := []struct { + name string + c NamingConfig + f map[string]string + ext string + want string + }{ + {"default", d, nightmare, ".FLAC", "Avenged Sevenfold/Nightmare/01 Nightmare.flac"}, + {"multi-disc disc 1 also gets its folder", d, song("artist", "The Beatles", "album", "White Album", "title", "Back in the USSR", "track", "1", "disc", "1", "disc_total", "2"), ".flac", + "The Beatles/White Album/Disc 01/01 Back in the USSR.flac"}, + {"multi-disc disc 2", d, song("artist", "The Beatles", "album", "White Album", "title", "Birthday", "track", "1", "disc", "2/2"), ".flac", + "The Beatles/White Album/Disc 02/01 Birthday.flac"}, + {"album artist wins", d, song("artist", "Queen", "album_artist", "Various Artists", "album", "Hits", "title", "Bohemian Rhapsody", "track", "12"), ".mp3", + "Various Artists/Hits/12 Bohemian Rhapsody.mp3"}, + {"year with empty brackets removed", with(func(c *NamingConfig) { c.AlbumFolder = "{Album Title} ({Release Year})" }), + song("artist", "A", "album", "B", "title", "S", "track", "3"), ".mp3", "A/B/03 S.mp3"}, + {"year present", with(func(c *NamingConfig) { c.AlbumFolder = "{Album Title} ({Release Year})" }), nightmare, ".flac", "Avenged Sevenfold/Nightmare (2010)/01 Nightmare.flac"}, + {"no track number", d, song("artist", "A", "album", "B", "title", "Song"), ".mp3", "A/B/Song.mp3"}, + {"separator left by missing number", with(func(c *NamingConfig) { c.TrackFormat = "{track:00} - {Track Title}" }), song("artist", "A", "album", "B", "title", "Song"), ".mp3", "A/B/Song.mp3"}, + {"three digit tracks", d, song("artist", "A", "album", "B", "title", "S", "track", "105"), ".mp3", "A/B/105 S.mp3"}, + {"NameThe and first character", with(func(c *NamingConfig) { + c.ArtistFolder = "{Artist NameFirstCharacter}" + c.AlbumFolder = "{Artist NameThe}" + }), + song("artist", "The Beatles", "album", "X", "title", "S", "track", "1"), ".mp3", "B/Beatles, The/01 S.mp3"}, + {"dotted and uppercase tokens", with(func(c *NamingConfig) { c.ArtistFolder = "{Artist.Name}"; c.TrackFormat = "{track:0} {TRACK TITLE}" }), nightmare, ".flac", + "Avenged.Sevenfold/Nightmare/1 NIGHTMARE.flac"}, + {"clean name", with(func(c *NamingConfig) { c.ArtistFolder = "{Artist CleanName}" }), song("artist", "AC/DC", "album", "B", "title", "S", "track", "1"), ".mp3", "ACDC/B/01 S.mp3"}, + {"illegal characters replaced, smart colon", d, song("artist", "AC/DC", "album", "Who Made Who?", "title", "Hells Bells: Live \"1986\"", "track", "7"), ".mp3", + "AC-DC/Who Made Who/07 Hells Bells - Live '1986'.mp3"}, + {"illegal characters removed, colon deleted", with(func(c *NamingConfig) { c.Illegal = "remove"; c.Colon = "delete" }), + song("artist", "AC/DC", "album", "B", "title", "Hells Bells: Live", "track", "7"), ".mp3", "ACDC/B/07 Hells Bells Live.mp3"}, + {"colon space-dash-space", with(func(c *NamingConfig) { c.Colon = "space_dash_space" }), song("artist", "A", "album", "B", "title", "Part:Two", "track", "1"), ".mp3", "A/B/01 Part - Two.mp3"}, + {"no hidden names", d, song("artist", "...And Justice", "album", "B", "title", "S", "track", "1"), ".mp3", "And Justice/B/01 S.mp3"}, + } + for _, c := range cases { + got, missing := renderPath(c.c, c.ext, c.f) + if got != c.want || missing != "" { + t.Errorf("%s: got %q (missing %q), want %q", c.name, got, missing, c.want) + } + } + for field, f := range map[string]map[string]string{ + "artist or album artist": song("album", "B", "title", "S"), + "album": song("artist", "A", "title", "S"), + "title": song("artist", "A", "album", "B"), + } { + if _, missing := renderPath(d, ".mp3", f); missing != field { + t.Errorf("want missing %q, got %q", field, missing) + } + } +} + +func TestValidateNaming(t *testing.T) { + bad := []func(*NamingConfig){ + func(c *NamingConfig) { c.ArtistFolder = "{Artist Name}/{Album Title}" }, + func(c *NamingConfig) { c.TrackFormat = "{track:00}" }, + func(c *NamingConfig) { c.TrackFormat = "{Bogus} {Track Title}" }, + func(c *NamingConfig) { c.MultiDiscFormat = "../{Track Title}" }, + func(c *NamingConfig) { c.AlbumFolder = "" }, + func(c *NamingConfig) { c.Colon = "weird" }, + func(c *NamingConfig) { c.AlbumFolder = "{Album Title" }, + } + for i, mod := range bad { + c := DefaultNaming() + mod(&c) + if ValidateNaming(c) == nil { + t.Errorf("case %d should be rejected: %+v", i, c) + } + } + for _, p := range NamingPresets { + if err := ValidateNaming(p.Config); err != nil { + t.Errorf("preset %q invalid: %v", p.Name, err) + } + } +} + +func TestNamingOfConvertsOldSettings(t *testing.T) { + c := NamingOf(store.Pair{OrganizeTemplate: "{artist}/{album} ({year})/{track} - {title}", OrganizeMultiDisc: "prefix", OrganizeDiscDigits: 1}) + if c.ArtistFolder != "{Artist Name}" || c.AlbumFolder != "{Album Title} ({Release Year})" || c.TrackFormat != "{track:00} - {Track Title}" || + c.MultiDiscFormat != "{medium:0}-{track:00} - {Track Title}" { + t.Fatalf("old settings not converted: %+v", c) + } + if got := NamingOf(store.Pair{}); got != DefaultNaming() { + t.Fatalf("pairs without settings should use the defaults, got %+v", got) + } + raw, _ := json.Marshal(NamingConfig{TrackFormat: "{track:0}. {Track Title}"}) + got := NamingOf(store.Pair{OrganizeConfig: raw}) + if got.TrackFormat != "{track:0}. {Track Title}" || got.ArtistFolder != "{Artist Name}" { + t.Fatalf("stored settings should win and gaps take defaults, got %+v", got) + } + ex := NamingExamples(DefaultNaming()) + if len(ex) != 4 || ex[1].Path != "The Beatles/The Beatles (White Album)/Disc 01/01 Back in the U.S.S.R.flac" { + t.Fatalf("examples: %+v", ex) + } +} + +func TestRenameNowPreviewAndApply(t *testing.T) { + ev := tagEnv(t, false) + mkTagged(t, filepath.Join(ev.slave, "in/a.mp3"), "title", "One", "artist", "Band", "album", "LP", "track", "1") + mkTagged(t, filepath.Join(ev.slave, "in/b.mp3"), "title", "Two", "artist", "Band", "album", "LP", "track", "2") + if _, err := ev.e.StartOrganizePreview(ev.pair.ID, "slave"); err != nil { + t.Fatal(err) + } + ev.wait() + plan, items := ev.e.OrganizePreview(ev.pair.ID) + if plan == nil || plan.Moves != 2 || len(items) != 2 { + t.Fatalf("preview: %+v %+v", plan, items) + } + var first int + for _, it := range items { + if it.From == "in/a.mp3" { + first = it.ID + } + } + if _, err := ev.e.StartOrganizeApply(ev.pair.ID, []int{first}); err != nil { + t.Fatal(err) + } + if j := ev.wait(); j.Results["renamed"] != 1 { + t.Fatalf("only the selected file should be renamed: %+v", j.Results) + } + if _, err := os.Stat(filepath.Join(ev.slave, "Band/LP/01 One.mp3")); err != nil { + t.Fatal(err) + } + if _, err := os.Stat(filepath.Join(ev.slave, "in/b.mp3")); err != nil { + t.Fatal("unselected files stay") + } + if p, _ := ev.e.OrganizePreview(ev.pair.ID); p != nil { + t.Fatal("the preview is stale after renaming and must be cleared") + } + if _, err := ev.e.StartOrganizeApply(ev.pair.ID, nil); err == nil { + t.Fatal("applying without a fresh preview must be refused") + } +} diff --git a/internal/engine/organize.go b/internal/engine/organize.go index 99a7ef3..d835905 100644 --- a/internal/engine/organize.go +++ b/internal/engine/organize.go @@ -14,8 +14,7 @@ import ( "strconv" "strings" "sync" - "unicode" - "unicode/utf8" + "time" "github.com/cdnutter/playlink/internal/fsops" "github.com/cdnutter/playlink/internal/store" @@ -27,61 +26,20 @@ import ( // (same inode, so hardlinks survive), never rewrites them, and every move is // an operation that can be undone. -const DefaultOrganizeTemplate = "{artist}/{album}/{track} {title}" - -var organizeTokens = []string{"artist", "track_artist", "album", "track", "title", "disc", "year", "genre"} - -var tokenRe = regexp.MustCompile(`\{([a-z_]+)\}`) - -// ValidateTemplate checks a naming template. -func ValidateTemplate(t string) error { - if strings.TrimSpace(t) == "" { - return errors.New("the naming pattern is empty") - } - if !strings.Contains(t, "{title}") { - return errors.New("the naming pattern must contain {title}") - } - if strings.HasPrefix(t, "/") || strings.Contains(t, "..") || strings.Contains(t, "\\") { - return errors.New("the naming pattern must be a relative path without .. or backslashes") - } - known := map[string]bool{} - for _, k := range organizeTokens { - known[k] = true - } - for _, m := range tokenRe.FindAllStringSubmatch(t, -1) { - if !known[m[1]] { - return fmt.Errorf("unknown token {%s}; use %s", m[1], "{"+strings.Join(organizeTokens, "}, {")+"}") - } - } - for _, part := range strings.Split(t, "/") { - if strings.TrimSpace(part) == "" { - return errors.New("the naming pattern has an empty folder name") - } - } - return nil -} - +// normalizeOrganize validates a pair's organize settings. func normalizeOrganize(p *store.Pair) error { - if strings.TrimSpace(p.OrganizeTemplate) == "" { - p.OrganizeTemplate = DefaultOrganizeTemplate - } - p.OrganizeTemplate = strings.TrimSpace(p.OrganizeTemplate) - if err := ValidateTemplate(p.OrganizeTemplate); err != nil { - return err - } - switch p.OrganizeMultiDisc { - case "": - p.OrganizeMultiDisc = "prefix" - case "prefix", "folder", "none": - default: - return errors.New("multi-disc style must be prefix, folder or none") - } - switch p.OrganizeDiscDigits { - case 0: - p.OrganizeDiscDigits = 2 - case 1, 2: - default: - return errors.New("disc numbers must use 1 or 2 digits") + if len(p.OrganizeConfig) > 0 && string(p.OrganizeConfig) != "{}" && string(p.OrganizeConfig) != "null" { + var c NamingConfig + if err := json.Unmarshal(p.OrganizeConfig, &c); err != nil { + return fmt.Errorf("naming settings: %w", err) + } + fill(&c, DefaultNaming()) + if err := ValidateNaming(c); err != nil { + return err + } + p.OrganizeConfig, _ = json.Marshal(c) + } else { + p.OrganizeConfig = nil // derived from older settings or defaults (NamingOf) } switch p.AutoOrganize { case "": @@ -93,38 +51,11 @@ func normalizeOrganize(p *store.Pair) error { return nil } -// ---- name cleanup ---- - -var unsafeChars = strings.NewReplacer( - "/", "-", "\\", "-", "|", "-", ":", " -", "*", "", "?", "", "\"", "'", "<", "", ">", "", -) - var spaces = regexp.MustCompile(`\s+`) // maxComponent keeps names well below the 255-byte filesystem limit. const maxComponent = 150 -// cleanComponent makes a tag value safe as a file or folder name, including -// on Windows/SMB shares: path separators and reserved characters are -// replaced, control characters dropped, and leading/trailing dots and spaces -// removed (a leading dot would hide the file). -func cleanComponent(s string) string { - s = unsafeChars.Replace(s) - s = strings.Map(func(r rune) rune { - if unicode.IsControl(r) { - return -1 - } - return r - }, s) - s = strings.TrimSpace(spaces.ReplaceAllString(s, " ")) - s = strings.Trim(s, ". ") - for len(s) > maxComponent { - _, size := utf8.DecodeLastRuneInString(s) - s = strings.TrimRight(s[:len(s)-size], ". ") - } - return s -} - func leadingNumber(s string) int { s = strings.TrimSpace(s) end := 0 @@ -135,75 +66,6 @@ func leadingNumber(s string) int { return n } -// renderName builds the organized path for a file from its tags. It returns -// the missing tag when a required one is empty. -func renderName(tpl, multiDisc string, discDigits int, ext string, f map[string]string) (string, string) { - if discDigits < 1 { - discDigits = 2 - } - discStr := func(d int) string { return fmt.Sprintf("%0*d", discDigits, d) } - artist := f[tags.AlbumArtist] - if strings.TrimSpace(artist) == "" { - artist = f[tags.Artist] - } - track := leadingNumber(f[tags.Track]) - total := leadingNumber(f[tags.TrackTotal]) - disc, discTotal := leadingNumber(f[tags.Disc]), leadingNumber(f[tags.DiscTotal]) - multi := discTotal > 1 || disc > 1 - trackStr := "" - if track > 0 { - width := 2 - if total >= 100 || track >= 100 { - width = 3 - } - trackStr = fmt.Sprintf("%0*d", width, track) - if multi && multiDisc == "prefix" && disc > 0 { - trackStr = discStr(disc) + "-" + trackStr - } - } - year := "" - if d := strings.TrimSpace(f[tags.Date]); len(d) >= 4 && leadingNumber(d[:4]) > 0 { - year = d[:4] - } - values := map[string]string{ - "artist": artist, "track_artist": f[tags.Artist], "album": f[tags.Album], "track": trackStr, - "title": f[tags.Title], "disc": discStr(disc), "year": year, "genre": f[tags.Genre], - } - if disc == 0 { - values["disc"] = "" - } - optional := map[string]bool{"track": true} - parts := strings.Split(tpl, "/") - for i, part := range parts { - missing := "" - out := tokenRe.ReplaceAllStringFunc(part, func(tok string) string { - name := tok[1 : len(tok)-1] - v := cleanComponent(values[name]) - if v == "" && !optional[name] && missing == "" { - missing = name - } - return v - }) - if missing != "" { - if missing == "artist" { - missing = "artist or album artist" - } - return "", missing - } - // A missing optional token must not leave "- " or double spaces. - out = strings.Trim(spaces.ReplaceAllString(out, " "), " -.") - if out == "" { - return "", "tags for " + part - } - parts[i] = out - } - if multi && multiDisc == "folder" && disc > 0 { - last := len(parts) - 1 - parts = append(parts[:last], "Disc "+discStr(disc), parts[last]) - } - return filepath.Join(parts...) + strings.ToLower(ext), "" -} - // ---- tag cache ---- type cachedTags struct { @@ -245,12 +107,13 @@ func (c *tagCache) get(ctx context.Context, t tags.Tools, abs string, in fsops.I // organizeItem is one file the organizer looked at. type organizeItem struct { - Side string - From string - To string - Move bool - Reason string // why it is skipped - Sidecars []string // e.g. lyrics files moving along + ID int `json:"id"` + Side string `json:"side"` + From string `json:"from"` + To string `json:"to,omitempty"` + Move bool `json:"move"` + Reason string `json:"reason,omitempty"` // why it is skipped + Sidecars []string `json:"sidecars,omitempty"` // e.g. lyrics files moving along ino uint64 size, mtime int64 @@ -258,11 +121,13 @@ type organizeItem struct { // organizePlan is what organizing would do right now. type organizePlan struct { - Scanned int - Conforming int - Moves int - Skips map[string]int - Items []organizeItem + Sides []string `json:"sides"` + CreatedAt int64 `json:"created_at"` + Scanned int `json:"scanned"` + Conforming int `json:"conforming"` + Moves int `json:"moves"` + Skips map[string]int `json:"skips"` + Items []organizeItem `json:"-"` } // sidecarExts move together with the song of the same name. @@ -283,7 +148,9 @@ func sidesOf(s string) []string { } func (e *Engine) planOrganize(ctx context.Context, j *Job, l *libs, sides []string) (*organizePlan, error) { - plan := &organizePlan{Skips: map[string]int{}} + plan := &organizePlan{Sides: sides, CreatedAt: time.Now().Unix(), Skips: map[string]int{}} + naming := NamingOf(l.pair) + id := 0 for _, side := range sides { root, _ := sideRoot(l, side) files := map[string]fsops.Info{} @@ -304,7 +171,7 @@ func (e *Engine) planOrganize(ctx context.Context, j *Job, l *libs, sides []stri item.Reason = "file type without editable tags" } else if fields, err := e.tagCache.get(ctx, e.tagTools, filepath.Join(root.Path, rel), in); err != nil { item.Reason = "tags could not be read" - } else if to, missing := renderName(l.pair.OrganizeTemplate, l.pair.OrganizeMultiDisc, l.pair.OrganizeDiscDigits, filepath.Ext(rel), fields); missing != "" { + } else if to, missing := renderPath(naming, filepath.Ext(rel), fields); missing != "" { item.Reason = "missing " + missing + " tag" } else if to == rel { plan.Conforming++ @@ -323,6 +190,8 @@ func (e *Engine) planOrganize(ctx context.Context, j *Job, l *libs, sides []stri item.Sidecars = sidecarsOf(root, rel) } } + id++ + item.ID = id if item.Move { plan.Moves++ } else { @@ -633,3 +502,88 @@ func (e *Engine) autoOrganize(ctx context.Context, j *Job, l *libs) error { e.log.Info("auto-organizing", "pair", l.pair.Name, "files", len(moves)) return e.applyOrganize(ctx, j, l, moves, "auto-organize") } + +// ---- rename now (preview, then apply) ---- + +// StartOrganizePreview checks which files would be renamed. +func (e *Engine) StartOrganizePreview(pairID int64, side string) (*Job, error) { + if !e.TagEditing() { + return nil, ErrNoTagTools + } + sides := sidesOf(side) + if sides == nil { + return nil, fmt.Errorf("%w: side must be slave, master or both", ErrInvalidBulk) + } + return e.startJob(pairID, "organize-preview", func(ctx context.Context, j *Job) error { + l, err := e.loadPair(ctx, pairID) + if err != nil { + return err + } + plan, err := e.planOrganize(ctx, j, l, sides) + if err != nil { + return err + } + e.plansMu.Lock() + if e.plans == nil { + e.plans = map[int64]*organizePlan{} + } + e.plans[pairID] = plan + e.plansMu.Unlock() + j.update(func(j *Job) { + j.Message = fmt.Sprintf("%d to rename, %d already organized, %d skipped", plan.Moves, plan.Conforming, len(plan.Items)-plan.Moves) + }) + return nil + }) +} + +// OrganizePreview returns the latest preview and its items. +func (e *Engine) OrganizePreview(pairID int64) (*organizePlan, []organizeItem) { + e.plansMu.Lock() + defer e.plansMu.Unlock() + p := e.plans[pairID] + if p == nil { + return nil, nil + } + return p, append([]organizeItem{}, p.Items...) +} + +// StartOrganizeApply renames the selected files of the latest preview (all +// when ids is empty), then rescans. Each file is checked again first. +func (e *Engine) StartOrganizeApply(pairID int64, ids []int) (*Job, error) { + e.plansMu.Lock() + plan := e.plans[pairID] + e.plansMu.Unlock() + if plan == nil { + return nil, fmt.Errorf("%w: check the files first", ErrInvalidBulk) + } + want := map[int]bool{} + for _, id := range ids { + want[id] = true + } + var items []organizeItem + for _, it := range plan.Items { + if it.Move && (len(want) == 0 || want[it.ID]) { + items = append(items, it) + } + } + if len(items) == 0 { + return nil, fmt.Errorf("%w: nothing to rename", ErrInvalidBulk) + } + return e.startJob(pairID, "organize", func(ctx context.Context, j *Job) error { + l, err := e.loadPair(ctx, pairID) + if err != nil { + return err + } + if err := e.applyOrganize(ctx, j, l, items, "organize"); err != nil { + return err + } + e.plansMu.Lock() + delete(e.plans, pairID) // paths changed: the preview is stale + e.plansMu.Unlock() + if e.st.DryRun(ctx) { + j.update(func(j *Job) { j.Message = "Dry run: renames recorded as planned in Activity" }) + return nil + } + return e.scan(ctx, j, pairID, "organize") + }) +} diff --git a/internal/engine/organize_test.go b/internal/engine/organize_test.go index 324e41a..47bb927 100644 --- a/internal/engine/organize_test.go +++ b/internal/engine/organize_test.go @@ -10,47 +10,6 @@ import ( "github.com/cdnutter/playlink/internal/store" ) -func TestRenderName(t *testing.T) { - f := func(kv ...string) map[string]string { - m := map[string]string{} - for i := 0; i < len(kv); i += 2 { - m[kv[i]] = kv[i+1] - } - return m - } - cases := []struct { - name, multi, ext string - digits int - fields map[string]string - want, missing string - }{ - {"basic", "prefix", ".mp3", 0, f("artist", "Avenged Sevenfold", "album", "Nightmare", "track", "1", "title", "Nightmare"), "Avenged Sevenfold/Nightmare/01 Nightmare.mp3", ""}, - {"album artist wins", "prefix", ".flac", 0, f("artist", "Avenged Sevenfold feat. X", "album_artist", "Avenged Sevenfold", "album", "A", "track", "3", "title", "T"), "Avenged Sevenfold/A/03 T.flac", ""}, - {"no track number", "prefix", ".mp3", 0, f("artist", "A", "album", "B", "title", "Song"), "A/B/Song.mp3", ""}, - {"missing album", "prefix", ".mp3", 0, f("artist", "A", "title", "Song"), "", "album"}, - {"missing title", "prefix", ".mp3", 0, f("artist", "A", "album", "B", "track", "1"), "", "title"}, - {"multi-disc prefix", "prefix", ".mp3", 0, f("artist", "A", "album", "B", "track", "4", "disc", "2", "disc_total", "2", "title", "S"), "A/B/02-04 S.mp3", ""}, - {"multi-disc folder", "folder", ".mp3", 0, f("artist", "A", "album", "B", "track", "4", "disc", "2", "title", "S"), "A/B/Disc 02/04 S.mp3", ""}, - {"single disc of one", "prefix", ".mp3", 0, f("artist", "A", "album", "B", "track", "4", "disc", "1", "disc_total", "1", "title", "S"), "A/B/04 S.mp3", ""}, - {"unsafe characters", "prefix", ".MP3", 0, f("artist", "AC/DC", "album", "Who Made Who?", "track", "7", "title", "Title: Sub \"Live\"..."), "AC-DC/Who Made Who/07 Title - Sub 'Live'.mp3", ""}, - {"no hidden names", "prefix", ".mp3", 0, f("artist", ".hidden", "album", "B", "title", "S"), "hidden/B/S.mp3", ""}, - {"unpadded disc prefix", "prefix", ".mp3", 1, f("artist", "A", "album", "B", "track", "4", "disc", "2", "disc_total", "2", "title", "S"), "A/B/2-04 S.mp3", ""}, - {"unpadded disc folder", "folder", ".mp3", 1, f("artist", "A", "album", "B", "track", "4", "disc", "2", "title", "S"), "A/B/Disc 2/04 S.mp3", ""}, - {"big albums use 3 digits", "prefix", ".mp3", 0, f("artist", "A", "album", "B", "track", "7", "track_total", "120", "title", "S"), "A/B/007 S.mp3", ""}, - } - for _, c := range cases { - got, missing := renderName(DefaultOrganizeTemplate, c.multi, c.digits, c.ext, c.fields) - if got != c.want || missing != c.missing { - t.Errorf("%s: got %q (missing %q), want %q (missing %q)", c.name, got, missing, c.want, c.missing) - } - } - for _, bad := range []string{"", "{artist}/{album}", "/{title}", "../{title}", "{artist}/{bogus} {title}", "{artist}//{title}"} { - if ValidateTemplate(bad) == nil { - t.Errorf("template %q should be rejected", bad) - } - } -} - func mkTagged(t *testing.T, path string, kv ...string) { t.Helper() os.MkdirAll(filepath.Dir(path), 0o755) diff --git a/internal/store/models.go b/internal/store/models.go index 58f615c..589aceb 100644 --- a/internal/store/models.go +++ b/internal/store/models.go @@ -137,42 +137,43 @@ func decodeWarnings(raw string) []Warning { // ---- pairs ---- type Pair struct { - ID int64 `json:"id"` - Name string `json:"name"` - MasterRoot string `json:"master_root"` - SlaveRoot string `json:"slave_root"` - QuarantineDir string `json:"quarantine_dir"` - Extensions []string `json:"extensions"` - AutoLinkIdentical bool `json:"auto_link_identical"` - ScanIntervalMinutes int `json:"scan_interval_minutes"` - RetentionDays int `json:"retention_days"` - SettleMinutes int `json:"settle_minutes"` - ApproxMatching bool `json:"approx_matching"` - ApproxThreshold int `json:"approx_threshold"` // percent - OrganizeTemplate string `json:"organize_template"` - OrganizeMultiDisc string `json:"organize_multidisc"` // prefix, folder or none - AutoOrganize string `json:"auto_organize"` // off, slave, master or both - OrganizeDiscDigits int `json:"organize_disc_digits"` // 2: Disc 01, 1: Disc 1 - LastScanAt *int64 `json:"last_scan_at"` - LastScanError string `json:"last_scan_error"` - LastScanWarnings []Warning `json:"last_scan_warnings"` - CreatedAt int64 `json:"created_at"` + ID int64 `json:"id"` + Name string `json:"name"` + MasterRoot string `json:"master_root"` + SlaveRoot string `json:"slave_root"` + QuarantineDir string `json:"quarantine_dir"` + Extensions []string `json:"extensions"` + AutoLinkIdentical bool `json:"auto_link_identical"` + ScanIntervalMinutes int `json:"scan_interval_minutes"` + RetentionDays int `json:"retention_days"` + SettleMinutes int `json:"settle_minutes"` + ApproxMatching bool `json:"approx_matching"` + ApproxThreshold int `json:"approx_threshold"` // percent + OrganizeTemplate string `json:"organize_template"` + OrganizeMultiDisc string `json:"organize_multidisc"` // prefix, folder or none + AutoOrganize string `json:"auto_organize"` // off, slave, master or both + OrganizeDiscDigits int `json:"-"` // superseded by OrganizeConfig; read to convert old settings + OrganizeConfig json.RawMessage `json:"-"` // naming settings (engine.NamingConfig) + LastScanAt *int64 `json:"last_scan_at"` + LastScanError string `json:"last_scan_error"` + LastScanWarnings []Warning `json:"last_scan_warnings"` + CreatedAt int64 `json:"created_at"` } const pairCols = `id, name, master_root, slave_root, quarantine_dir, extensions, auto_link_identical, scan_interval_minutes, retention_days, settle_minutes, approx_matching, approx_threshold, organize_template, - organize_multidisc, auto_organize, organize_disc_digits, last_scan_at, last_scan_error, + organize_multidisc, auto_organize, organize_disc_digits, organize_config, last_scan_at, last_scan_error, last_scan_warnings, created_at` type scanner interface{ Scan(...any) error } func scanPair(r scanner) (Pair, error) { var p Pair - var exts, warns string + var exts, warns, orgCfg string var last sql.NullInt64 err := r.Scan(&p.ID, &p.Name, &p.MasterRoot, &p.SlaveRoot, &p.QuarantineDir, &exts, &p.AutoLinkIdentical, &p.ScanIntervalMinutes, &p.RetentionDays, &p.SettleMinutes, &p.ApproxMatching, &p.ApproxThreshold, &p.OrganizeTemplate, - &p.OrganizeMultiDisc, &p.AutoOrganize, &p.OrganizeDiscDigits, &last, &p.LastScanError, + &p.OrganizeMultiDisc, &p.AutoOrganize, &p.OrganizeDiscDigits, &orgCfg, &last, &p.LastScanError, &warns, &p.CreatedAt) if err != nil { return p, err @@ -182,6 +183,9 @@ func scanPair(r scanner) (Pair, error) { } p.Extensions = strings.Split(exts, ",") p.LastScanWarnings = decodeWarnings(warns) + if orgCfg != "" { + p.OrganizeConfig = json.RawMessage(orgCfg) + } return p, nil } @@ -215,11 +219,11 @@ func (s *Store) SavePair(ctx context.Context, p *Pair) error { if p.ID == 0 { res, err := s.DB.ExecContext(ctx, `INSERT INTO pairs (name, master_root, slave_root, quarantine_dir, extensions, auto_link_identical, scan_interval_minutes, retention_days, settle_minutes, approx_matching, approx_threshold, - organize_template, organize_multidisc, auto_organize, organize_disc_digits, created_at) - VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, + organize_template, organize_multidisc, auto_organize, organize_disc_digits, organize_config, created_at) + VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, p.Name, p.MasterRoot, p.SlaveRoot, p.QuarantineDir, exts, p.AutoLinkIdentical, p.ScanIntervalMinutes, p.RetentionDays, p.SettleMinutes, p.ApproxMatching, p.ApproxThreshold, - p.OrganizeTemplate, p.OrganizeMultiDisc, p.AutoOrganize, p.OrganizeDiscDigits, now()) + p.OrganizeTemplate, p.OrganizeMultiDisc, p.AutoOrganize, p.OrganizeDiscDigits, string(p.OrganizeConfig), now()) if err != nil { return err } @@ -229,10 +233,10 @@ func (s *Store) SavePair(ctx context.Context, p *Pair) error { _, err := s.DB.ExecContext(ctx, `UPDATE pairs SET name = ?, master_root = ?, slave_root = ?, quarantine_dir = ?, extensions = ?, auto_link_identical = ?, scan_interval_minutes = ?, retention_days = ?, settle_minutes = ?, approx_matching = ?, approx_threshold = ?, organize_template = ?, organize_multidisc = ?, auto_organize = ?, - organize_disc_digits = ? WHERE id = ?`, + organize_disc_digits = ?, organize_config = ? WHERE id = ?`, p.Name, p.MasterRoot, p.SlaveRoot, p.QuarantineDir, exts, p.AutoLinkIdentical, p.ScanIntervalMinutes, p.RetentionDays, p.SettleMinutes, p.ApproxMatching, p.ApproxThreshold, - p.OrganizeTemplate, p.OrganizeMultiDisc, p.AutoOrganize, p.OrganizeDiscDigits, p.ID) + p.OrganizeTemplate, p.OrganizeMultiDisc, p.AutoOrganize, p.OrganizeDiscDigits, string(p.OrganizeConfig), p.ID) return err } diff --git a/internal/store/store.go b/internal/store/store.go index 32dd2df..447d61e 100644 --- a/internal/store/store.go +++ b/internal/store/store.go @@ -129,6 +129,9 @@ var migrations = []string{ // 8: zero-padded disc numbers (Disc 01) by default. `ALTER TABLE pairs ADD COLUMN organize_disc_digits INTEGER NOT NULL DEFAULT 2;`, + + // 9: Lidarr-style naming (artist/album folder and track formats) as JSON. + `ALTER TABLE pairs ADD COLUMN organize_config TEXT NOT NULL DEFAULT '';`, } // SchemaVersion is the newest database schema this build knows. diff --git a/web/src/api.ts b/web/src/api.ts index 64738b5..fe4fa1d 100644 --- a/web/src/api.ts +++ b/web/src/api.ts @@ -76,10 +76,8 @@ export type Pair = { settle_minutes: number; approx_matching: boolean; approx_threshold: number; - organize_template: string; - organize_multidisc: "prefix" | "folder" | "none"; auto_organize: "off" | "slave" | "master" | "both"; - organize_disc_digits: number; + naming: Naming; last_scan_at: number | null; last_scan_error: string; last_scan_warnings: ScanWarning[]; @@ -100,10 +98,7 @@ export type PairInput = Pick< | "settle_minutes" | "approx_matching" | "approx_threshold" - | "organize_template" - | "organize_multidisc" | "auto_organize" - | "organize_disc_digits" >; export type ProbeInfo = { @@ -245,3 +240,16 @@ export type TagFile = { export type BackupConfig = { folder: string; interval_days: number; retention_days: number; before_actions: boolean }; export type Backup = { name: string; type: "manual" | "scheduled" | "action"; size: number; created: number }; + +export type Naming = { + artist_folder: string; + album_folder: string; + track_format: string; + multi_disc_format: string; + colon: "smart" | "delete" | "dash" | "space_dash" | "space_dash_space"; + illegal: "replace" | "remove"; +}; + +export type OrganizeItem = { id: number; side: Side; from: string; to?: string; move: boolean; reason?: string; sidecars?: string[] }; + +export type OrganizePlan = { sides: Side[]; created_at: number; scanned: number; conforming: number; moves: number; skips: Record }; diff --git a/web/src/pages/Organize.tsx b/web/src/pages/Organize.tsx index 3414a7d..1364f0b 100644 --- a/web/src/pages/Organize.tsx +++ b/web/src/pages/Organize.tsx @@ -1,70 +1,61 @@ -import { useEffect, useState } from "react"; -import { useMutation, useQueryClient } from "@tanstack/react-query"; -import { AlertTriangle, FolderTree } from "lucide-react"; -import { api, type Pair } from "../api"; +import { useEffect, useMemo, useRef, useState } from "react"; +import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query"; +import { AlertTriangle, ArrowRight, ChevronDown, ChevronRight, Folder, FolderTree, Tags as TagsIcon } from "lucide-react"; +import { api, type Job, type Naming, type OrganizeItem, type OrganizePlan, type Pair, type Side } from "../api"; import { useInfo } from "../App"; -import { Alert, Button, Card, Field, inputCls } from "../ui"; +import { Alert, Badge, Button, Card, Field, Modal, Spinner, cx, inputCls } from "../ui"; import { useToast } from "../toast"; +import { TagEditor } from "./Tags"; -const TOKENS: [string, string][] = [ - ["artist", "album artist, or artist"], - ["album", "album"], - ["track", "track number, 01"], - ["title", "title"], - ["year", "year"], - ["disc", "disc number"], - ["track_artist", "the song's artist"], - ["genre", "genre"], +type NamingInfo = { defaults: Naming; presets: { name: string; config: Naming }[]; tokens: [string, string][] }; +type Scope = Side | "both"; + +const FORMAT_FIELDS: { key: keyof Naming; label: string; hint: string }[] = [ + { key: "artist_folder", label: "Artist folder", hint: "One folder name." }, + { key: "album_folder", label: "Album folder", hint: "One folder name, inside the artist folder." }, + { key: "track_format", label: "Track", hint: "File name inside the album folder. May add subfolders with /." }, + { key: "multi_disc_format", label: "Multi-disc track", hint: "Used when an album has more than one disc." }, ]; -const SAMPLE: Record = { - artist: "Avenged Sevenfold", - album: "Nightmare", - track: "01", - title: "Nightmare", - year: "2010", - disc: "1", - track_artist: "Avenged Sevenfold", - genre: "Metal", -}; - -/** Renders the pattern for a sample song; disc 2 shows the multi-disc style. */ -function example(tpl: string, multi?: Pair["organize_multidisc"], digits = 2) { - const d = digits === 1 ? "2" : "02"; - const values: Record = multi - ? { ...SAMPLE, track: multi === "prefix" ? `${d}-04` : "04", title: "Victim", disc: d } - : { ...SAMPLE, disc: digits === 1 ? "1" : "01" }; - let parts = tpl.split("/").map((part) => part.replace(/\{([a-z_]+)\}/g, (_, k: string) => values[k] ?? `{${k}}`)); - if (multi === "folder") parts = [...parts.slice(0, -1), `Disc ${d}`, parts[parts.length - 1]]; - return parts.join("/") + ".flac"; -} - export function OrganizeTab({ pair }: { pair: Pair }) { const info = useInfo(); if (info.data && !info.data.tag_editing) return Organizing reads tags with ffmpeg and ffprobe, which were not found. The Docker image includes both.; return (
- + +
); } -function NamingSettings({ pair }: { pair: Pair }) { +// ---- naming settings ---- + +function NamingCard({ pair }: { pair: Pair }) { const qc = useQueryClient(); const toast = useToast(); - const [tpl, setTpl] = useState(pair.organize_template); - const [multi, setMulti] = useState(pair.organize_multidisc); + const info = useQuery({ queryKey: ["naming-info"], queryFn: () => api.get("/naming"), staleTime: Infinity }); + const [cfg, setCfg] = useState(pair.naming); const [auto, setAuto] = useState(pair.auto_organize); - const [digits, setDigits] = useState(pair.organize_disc_digits || 2); + const [showTokens, setShowTokens] = useState(false); + const focused = useRef<{ key: keyof Naming; el: HTMLInputElement } | null>(null); + const saved = JSON.stringify(pair.naming); useEffect(() => { - setTpl(pair.organize_template); - setMulti(pair.organize_multidisc); + setCfg(pair.naming); setAuto(pair.auto_organize); - setDigits(pair.organize_disc_digits || 2); - }, [pair.id, pair.organize_template, pair.organize_multidisc, pair.auto_organize, pair.organize_disc_digits]); - const dirty = - tpl !== pair.organize_template || multi !== pair.organize_multidisc || auto !== pair.auto_organize || digits !== (pair.organize_disc_digits || 2); + }, [pair.id, saved, pair.auto_organize]); // eslint-disable-line react-hooks/exhaustive-deps + const dirty = JSON.stringify(cfg) !== saved || auto !== pair.auto_organize; + + // Examples are rendered by the server with the same code as real renames. + const [debounced, setDebounced] = useState(cfg); + useEffect(() => { + const t = setTimeout(() => setDebounced(cfg), 250); + return () => clearTimeout(t); + }, [cfg]); + const examples = useQuery({ + queryKey: ["naming-examples", JSON.stringify(debounced)], + queryFn: () => api.post<{ examples: { label: string; path: string }[]; error?: string }>("/naming/examples", debounced), + }); const save = useMutation({ mutationFn: () => @@ -80,19 +71,30 @@ function NamingSettings({ pair }: { pair: Pair }) { settle_minutes: pair.settle_minutes, approx_matching: pair.approx_matching, approx_threshold: pair.approx_threshold, - organize_template: tpl, - organize_multidisc: multi, auto_organize: auto, - organize_disc_digits: digits, + naming: cfg, }), onSuccess: () => { - toast("ok", "Naming settings saved. Preview again to see the effect."); + toast("ok", "Naming saved"); qc.invalidateQueries({ queryKey: ["pair", pair.id] }); qc.invalidateQueries({ queryKey: ["pairs"] }); }, onError: (e) => toast("err", e.message), }); + const insert = (token: string) => { + const f = focused.current; + if (!f) return; + const v = cfg[f.key] as string; + const start = f.el.selectionStart ?? v.length; + const end = f.el.selectionEnd ?? v.length; + setCfg({ ...cfg, [f.key]: v.slice(0, start) + token + v.slice(end) }); + requestAnimationFrame(() => { + f.el.focus(); + f.el.setSelectionRange(start + token.length, start + token.length); + }); + }; + return (
@@ -100,57 +102,104 @@ function NamingSettings({ pair }: { pair: Pair }) {

File naming

-

- Files that don't follow this layout are renamed from their tags during scans, when Organize automatically is on. Nothing else about - a file changes. -

+

How files are named from their tags, in the style of Lidarr. Only the name and folder change.

- - Folders are separated by /. The file extension is added automatically.}> - setTpl(e.target.value)} spellCheck={false} /> - -
- {TOKENS.map(([t, help]) => ( - + + {info.data && ( +
+ Presets: + {info.data.presets.map((p) => ( + + ))} +
+ )} + +
+ {FORMAT_FIELDS.map((f) => ( + + (focused.current = { key: f.key, el: e.currentTarget })} + onChange={(e) => setCfg({ ...cfg, [f.key]: e.target.value })} + /> + ))}
-
-
Example
-
{example(tpl, undefined, digits)}
- {multi !== "none" && ( -
- {example(tpl, multi, digits)} (disc 2 of a multi-disc album) + +
+ + {showTokens && info.data && ( +
+ {info.data.tokens.map(([tok, ex]) => ( + + ))} +

+ Write a token with dots or underscores to use them between words ({"{Artist.Name}"} → + Avenged.Sevenfold), or in capitals or lower case to change the case ({"{ARTIST NAME}"}). +

)}
-
- - setCfg({ ...cfg, colon: e.target.value as Naming["colon"] })}> + + + + + - - setCfg({ ...cfg, illegal: e.target.value as Naming["illegal"] })}> + + - + setScope(e.target.value as Scope)}> + + + + + +
+ {open && setOpen(false)} />} + + ); +} + +type Stage = { kind: "checking"; job?: Job } | { kind: "ready" } | { kind: "error"; message: string }; + +function RenameFilesDialog({ pair, scope, onClose }: { pair: Pair; scope: Scope; onClose: () => void }) { + const qc = useQueryClient(); + const toast = useToast(); + const dry = useInfo().data?.dry_run ?? true; + const [stage, setStage] = useState({ kind: "checking" }); + const [data, setData] = useState<{ plan: OrganizePlan; items: OrganizeItem[] } | null>(null); + const [view, setView] = useState<"changes" | "skipped">("changes"); + const [sel, setSel] = useState>(new Set()); + const [editTags, setEditTags] = useState(null); + + // Start a check and follow its job until it finishes. + const check = async () => { + setStage({ kind: "checking" }); + try { + const job = await api.post(`/pairs/${pair.id}/organize/preview`, { side: scope }); + for (;;) { + await new Promise((r) => setTimeout(r, 600)); + const j = await api.get(`/pairs/${pair.id}/job`); + if (!j || j.id !== job.id) break; + if (j.state !== "running") { + if (j.state !== "done") throw new Error(j.error || j.state); + break; + } + setStage({ kind: "checking", job: j }); + } + const res = await api.get<{ plan: OrganizePlan | null; items: OrganizeItem[] }>(`/pairs/${pair.id}/organize/plan`); + if (!res.plan) throw new Error("The check did not produce a result. Try again."); + setData({ plan: res.plan, items: res.items }); + setSel(new Set(res.items.filter((i) => i.move).map((i) => i.id))); + setStage({ kind: "ready" }); + } catch (e) { + setStage({ kind: "error", message: (e as Error).message }); + } + }; + useEffect(() => { + check(); + }, []); // eslint-disable-line react-hooks/exhaustive-deps + + const moves = useMemo(() => (data?.items ?? []).filter((i) => i.move), [data]); + const skipped = useMemo(() => (data?.items ?? []).filter((i) => !i.move), [data]); + // Group the changes by the folder they end up in. + const groups = useMemo(() => { + const m = new Map(); + for (const it of moves) { + const key = `${it.side}\u0000${it.to!.split("/").slice(0, -1).join("/")}`; + m.set(key, [...(m.get(key) ?? []), it]); + } + return [...m.entries()].sort(([a], [b]) => a.localeCompare(b)); + }, [moves]); + const both = (data?.plan.sides.length ?? 0) > 1; + const toggle = (ids: number[], on: boolean) => + setSel((s) => { + const n = new Set(s); + ids.forEach((id) => (on ? n.add(id) : n.delete(id))); + return n; + }); + + const apply = useMutation({ + mutationFn: () => api.post(`/pairs/${pair.id}/organize/apply`, { ids: sel.size === moves.length ? [] : [...sel] }), + onSuccess: () => { + toast("ok", dry ? "Started (dry run): renames are recorded as planned only" : `Renaming ${sel.size} files. The library is rescanned afterwards.`); + qc.invalidateQueries({ queryKey: ["pair", pair.id] }); + onClose(); + }, + onError: (e) => toast("err", e.message), + }); + + return ( + + {stage.kind === "checking" && ( +
+
+ {stage.job?.phase || "Checking files"}… +
+ {stage.job && stage.job.total > 0 && ( +
+
+
+ )} +

Reading each file's tags. Nothing is renamed until you confirm.

+
+ )} + {stage.kind === "error" && ( +
+ {stage.message} + +
+ )} + {stage.kind === "ready" && data && ( +
+
+ + + + +
+ + {moves.length === 0 && skipped.length === 0 && Everything already follows the naming.} + + {(moves.length > 0 || skipped.length > 0) && ( +
+ {(["changes", "skipped"] as const).map((v) => ( + + ))} +
+ )} + + {view === "changes" && moves.length > 0 && ( +
+ +
+ {groups.map(([key, items]) => { + const [side, folder] = key.split("\u0000"); + const ids = items.map((i) => i.id); + return ( +
+ + {items.map((it) => ( + + ))} +
+ ); + })} +
+
+ )} + + {view === "skipped" && ( +
+
    + {Object.entries(data.plan.skips).map(([why, n]) => ( +
  • + {n} {why} +
    • + ))} +
+
+ {skipped.map((it) => ( +
+ {both && {it.side}} +
+
{it.from}
+
{it.reason}
+
+ {it.reason?.startsWith("missing") && ( + + )} +
+ ))} +
+

After fixing tags, run Rename now again to include those files.

+
+ )} + + {moves.length > 0 && ( +
    +
  • Files move inside their own library; their contents and hardlinks don't change.
    • +
  • Lyrics files with the same name move along; cover art follows when a whole folder moves. Emptied folders are removed.
    • +
  • + Playlists or apps that point at the old paths will need updating. +
    • + {!both &&
  • Only the {data.plan.sides[0]} library is renamed; paths may then differ from the other library (hardlinked songs stay paired).
    • } +
  • Each rename is in History and can be undone. The library is rescanned when it finishes.
    • +
+ )} + {dry && moves.length > 0 && Dry run is on, so the renames are recorded as planned in Activity. No files move.} +
+ )} +
+ + {stage.kind === "ready" && moves.length > 0 && ( + + )} +
+ {editTags && setEditTags(null)} />} + + ); +} + +function Stat({ label, value, tone }: { label: string; value: number; tone?: string }) { + return ( +
+
{value}
+
{label}
+
+ ); +} diff --git a/web/src/pages/PairForm.tsx b/web/src/pages/PairForm.tsx index f29accf..7f45de5 100644 --- a/web/src/pages/PairForm.tsx +++ b/web/src/pages/PairForm.tsx @@ -25,10 +25,7 @@ export function PairForm({ pair, open, onClose }: { pair?: Pair; open: boolean; settle_minutes: 10, approx_matching: false, approx_threshold: 85, - organize_template: "", - organize_multidisc: "prefix", auto_organize: "off", - organize_disc_digits: 2, }; const [f, setF] = useState(pair ?? blank); const [exts, setExts] = useState((pair?.extensions ?? []).join(", ")); @@ -56,11 +53,8 @@ export function PairForm({ pair, open, onClose }: { pair?: Pair; open: boolean; settle_minutes: f.settle_minutes, approx_matching: f.approx_matching, approx_threshold: f.approx_threshold, - // Edited on the Organize tab; sent unchanged so saving here keeps them. - organize_template: f.organize_template, - organize_multidisc: f.organize_multidisc, + // Edited on the Organize tab; sent unchanged so saving here keeps it. auto_organize: f.auto_organize, - organize_disc_digits: f.organize_disc_digits, extensions: exts.split(",").map((s) => s.trim()).filter(Boolean), }); const set = (k: K, v: PairInput[K]) => {