From 5d01d6ab3450943004aa12a9aca12ae413246e5c Mon Sep 17 00:00:00 2001 From: Claude Date: Mon, 12 Oct 2026 09:56:54 +0000 Subject: [PATCH] fix(archive): move sequences nested in a renamed folder with it A mass rename or move of a sequence whose folder holds other sequences moved their files without updating their index rows, and a target inside another sequence's folder could nest one sequence in another. The plan now carries the nested sequences (listed in the dry run, moved with the folder that holds them, inner folders leaving first) and refuses a target inside a sequence folder with a localized NestedRenameException (CD-4). The Archive screen counts only the selected sequences in its summary. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_012iLMBNwBE2GnphAsu4cjaC --- i18n/en/Archive.resx | 1 + i18n/it/Archive.it.resx | 1 + src/Titano.App/Archive/ArchiveFailures.cs | 3 +- src/Titano.App/Archive/MassOperations.cs | 4 +- src/Titano.Core/Archiving/MassRename.cs | 57 ++++++++++++++--- src/Titano.Data/Archiving/MassRenamer.cs | 17 ++++- .../Archiving/MassRenameTests.cs | 63 +++++++++++++++++++ 7 files changed, 134 insertions(+), 12 deletions(-) diff --git a/i18n/en/Archive.resx b/i18n/en/Archive.resx index 79ccbb34..5c11be26 100644 --- a/i18n/en/Archive.resx +++ b/i18n/en/Archive.resx @@ -81,6 +81,7 @@ The copy of {0} does not match the original.long: error sentence {0} could not be added to the sequence.long: error sentence {0} is already in the library.long: error sentence + {0} would be inside the sequence folder {1}.long: error sentence {0} was written by a newer Titano (format {1}).long: error sentence The archive {0} is offline.long: error sentence The archive {0} is read-only.long: error sentence diff --git a/i18n/it/Archive.it.resx b/i18n/it/Archive.it.resx index 889e7ad4..06606110 100644 --- a/i18n/it/Archive.it.resx +++ b/i18n/it/Archive.it.resx @@ -76,6 +76,7 @@ La copia di {0} non corrisponde all'originale. Impossibile aggiungere {0} alla sequenza. {0} è già nella libreria. + {0} finirebbe dentro la cartella della sequenza {1}. {0} è stato scritto da un Titano più recente (formato {1}). L'archivio {0} non è raggiungibile. L'archivio {0} è di sola lettura. diff --git a/src/Titano.App/Archive/ArchiveFailures.cs b/src/Titano.App/Archive/ArchiveFailures.cs index b7013175..94565389 100644 --- a/src/Titano.App/Archive/ArchiveFailures.cs +++ b/src/Titano.App/Archive/ArchiveFailures.cs @@ -17,7 +17,8 @@ public static class ArchiveFailures ArchiveOfflineException offline => Loc.L(offline.Availability == ArchiveAvailability.ReadOnly ? "Archive.Error.ReadOnly" : "Archive.Error.Offline", Formatting.LeftToRight(offline.Root)), // Already one localized sentence each. - LeaseUnavailableException or NewerFormatException or StaleRenamePlanException or StaleDeletePlanException or SequenceInLibraryException => ex.Message, + LeaseUnavailableException or NewerFormatException or StaleRenamePlanException or NestedRenameException or StaleDeletePlanException + or SequenceInLibraryException => ex.Message, UnauthorizedAccessException => Loc.L("Archive.Failed.Access"), DatabaseException => Loc.L("Archive.Failed.Index"), ArgumentException => Loc.L("Archive.Failed.Gone"), diff --git a/src/Titano.App/Archive/MassOperations.cs b/src/Titano.App/Archive/MassOperations.cs index 4bcb2d3b..7be16553 100644 --- a/src/Titano.App/Archive/MassOperations.cs +++ b/src/Titano.App/Archive/MassOperations.cs @@ -41,8 +41,8 @@ public static class MassRename : new RenameRow(s.SequenceId, s.FromTitle ?? string.Empty, s.ToTitle ?? string.Empty)), ]; - /// "12 of 36 sequences change". - public static string Summary(RenamePlan plan, int setSize) => Loc.Plural("Archive.Rename.Summary", plan.Steps.Count, setSize); + /// "12 of 36 sequences change"; sequences that only move with a folder they are in are listed, not counted. + public static string Summary(RenamePlan plan, int setSize) => Loc.Plural("Archive.Rename.Summary", plan.Steps.Count(s => !s.Carried), setSize); } /// Adding and removing tags on a set of sequences (BRIEF §12.5 Retag). diff --git a/src/Titano.Core/Archiving/MassRename.cs b/src/Titano.Core/Archiving/MassRename.cs index caf423c9..c653b694 100644 --- a/src/Titano.Core/Archiving/MassRename.cs +++ b/src/Titano.Core/Archiving/MassRename.cs @@ -1,6 +1,7 @@ using System.Globalization; using System.Text.Json; using Titano.Core.IO; +using Titano.Core.Localization; using Titano.Core.Naming; namespace Titano.Core.Archiving; @@ -9,11 +10,20 @@ namespace Titano.Core.Archiving; public sealed record RenameSubject(Guid SequenceId, string Folder, string? Title, DateTime? FirstCapture, string? CameraMake, string? CameraModel, string? Lens); /// One sequence's change: its folder, its title, or both. -public sealed record RenameStep(Guid SequenceId, string FromFolder, string ToFolder, string? FromTitle, string? ToTitle) +/// The folder moves only because a folder it is inside moves (a sequence nested in another). +public sealed record RenameStep(Guid SequenceId, string FromFolder, string ToFolder, string? FromTitle, string? ToTitle, bool Carried = false) { public bool MovesFolder => !string.Equals(FromFolder, ToFolder, StringComparison.Ordinal); } +/// A planned folder would lie inside a sequence's folder (nesting one sequence in another); nothing is planned. +public sealed class NestedRenameException(string target, string folder) + : ArgumentException(Loc.L("Archive.Error.NestedTarget", target, folder)) +{ + public string Target { get; } = target; + public string Folder { get; } = folder; +} + /// The exact changes a mass rename will make (its dry run); applying it makes exactly these. public sealed record RenamePlan(Guid Id, Guid ArchiveId, IReadOnlyList Steps); @@ -50,16 +60,21 @@ public static class RenamePlanner /// Expands (where {title} is the current title) and then /// (where {title} is the new title) for every subject. A target folder /// that is any current sequence folder, exists on disk or was given to an earlier subject gets " (2)", " (3)"…. - /// Null templates leave that part unchanged; subjects without a change produce no step. + /// Null templates leave that part unchanged; subjects without a change produce no step. A folder that moves takes + /// the sequences inside it along: each gets a step after every move, so the index + /// follows its files; a selected sequence inside a moving folder that moves elsewhere leaves first. /// /// Every sequence folder of the archive (renamed or not). + /// The archive's other sequences inside a subject's folder, with their titles. + /// A target lies inside a sequence's folder, or inside another target. public static RenamePlan Plan(Guid archiveId, IReadOnlyList subjects, string? folderTemplate, string? titleTemplate, - IEnumerable occupied, Func existsOnDisk) + IEnumerable occupied, Func existsOnDisk, IReadOnlyList? nested = null) { var folder = folderTemplate is null ? null : PathTemplate.Parse(folderTemplate); var title = titleTemplate is null ? null : PathTemplate.Parse(titleTemplate); - var claimed = new HashSet(occupied, StringComparer.OrdinalIgnoreCase); - var steps = new List(); + var taken = occupied.ToList(); + var claimed = new HashSet(taken, StringComparer.OrdinalIgnoreCase); + var own = new List(subjects.Count); foreach (var s in subjects) { var context = new NamingContext @@ -80,11 +95,39 @@ public static class RenamePlanner newFolder = expanded.Equals(s.Folder, StringComparison.OrdinalIgnoreCase) ? expanded : Unique(expanded, claimed, existsOnDisk); claimed.Add(newFolder); } - if (newFolder != s.Folder || newTitle != s.Title) steps.Add(new RenameStep(s.SequenceId, s.Folder, newFolder, s.Title, newTitle)); + own.Add(new RenameStep(s.SequenceId, s.Folder, newFolder, s.Title, newTitle)); } - return new RenamePlan(Guid.CreateVersion7(), archiveId, steps); + + var moving = own.Where(s => s.MovesFolder).ToList(); + foreach (var step in moving) + { + // Into a sequence's folder (its own included) or another target: one sequence would end up inside another. + var host = taken.Concat(moving.Where(m => m != step).Select(m => m.ToFolder)).FirstOrDefault(f => IsInside(f, step.ToFolder)); + if (host is not null) throw new NestedRenameException(step.ToFolder, host); + } + var steps = new List<(RenameStep Step, int Order)>(); + foreach (var step in own.Concat((nested ?? []).Select(n => new RenameStep(n.SequenceId, n.Folder, n.Folder, n.Title, n.Title)))) + { + // The nearest folder around it that moves carries it; a sequence that moves elsewhere leaves before its folder does. + var carrier = step.MovesFolder ? null : moving.Where(m => IsInside(m.FromFolder, step.FromFolder)).MaxBy(m => m.FromFolder.Length); + if (carrier is not null) + steps.Add((step with { ToFolder = carrier.ToFolder + step.FromFolder[carrier.FromFolder.Length..], Carried = true }, 1)); + else if (step.MovesFolder) + steps.Add((step, -moving.Count(m => m != step && IsInside(m.FromFolder, step.FromFolder)))); + else if (step.FromTitle != step.ToTitle) + steps.Add((step, 0)); + } + // Stable: subjects keep their order, sequences inside moving folders move out first, carried ones come last. + return new RenamePlan(Guid.CreateVersion7(), archiveId, [.. steps.OrderBy(s => s.Order).Select(s => s.Step)]); } + /// + /// Whether lies inside (archive-relative, forward slashes); the + /// archive root, a sequence only when a folder was adopted in place, counts as containing nothing. + /// + public static bool IsInside(string folder, string path) => + folder.Length > 0 && path.Length > folder.Length + 1 && path[folder.Length] == '/' && path.StartsWith(folder, StringComparison.OrdinalIgnoreCase); + /// /// Moves the folder of a step; idempotent so a resumed plan can repeat it: an already moved folder is accepted, /// a case-only change goes through a temporary name (case-insensitive file systems). diff --git a/src/Titano.Data/Archiving/MassRenamer.cs b/src/Titano.Data/Archiving/MassRenamer.cs index 9cc0af2e..ad46a81b 100644 --- a/src/Titano.Data/Archiving/MassRenamer.cs +++ b/src/Titano.Data/Archiving/MassRenamer.cs @@ -32,6 +32,8 @@ public sealed class MassRenamer /// New folder template ({title} = the new title), or null to keep folders. /// New title template ({title} = the current title), or null to keep titles. + /// Sequences nested in a folder that moves are part of the plan (they move with it); see . + /// A new folder would lie inside a sequence's folder. public async Task PlanAsync(Archive archive, IReadOnlyList sequenceIds, string? folderTemplate, string? titleTemplate, CancellationToken cancellationToken = default) { @@ -42,12 +44,23 @@ public sealed class MassRenamer { if (await _db.Sequences.GetAsync(id, cancellationToken).ConfigureAwait(false) is not { } s || s.ArchiveId != archive.Id) throw new ArgumentException($"Sequence {id} is not in archive {archive.Id}.", nameof(sequenceIds)); - subjects.Add(new RenameSubject(s.Id, s.Folder, s.Title, s.FirstCapture, s.CameraMake, s.CameraModel, s.Lens)); + subjects.Add(Subject(s)); + } + var nested = new List(); + if (folderTemplate is not null) + { + var selected = sequenceIds.ToHashSet(); + foreach (var location in locations.Where(l => !selected.Contains(l.Id) && subjects.Any(s => RenamePlanner.IsInside(s.Folder, l.Folder)))) + { + if (await _db.Sequences.GetAsync(location.Id, cancellationToken).ConfigureAwait(false) is { } inner) nested.Add(Subject(inner)); + } } return RenamePlanner.Plan(archive.Id, subjects, folderTemplate, titleTemplate, locations.Select(l => l.Folder), - folder => Directory.Exists(paths.Sequence(folder).Folder)); + folder => Directory.Exists(paths.Sequence(folder).Folder), nested); } + private static RenameSubject Subject(Sequence s) => new(s.Id, s.Folder, s.Title, s.FirstCapture, s.CameraMake, s.CameraModel, s.Lens); + /// Applies a plan; each completed step is journaled before the next starts. /// A sequence is no longer where the plan expects it; nothing of that step was changed. public Task ApplyAsync(Archive archive, RenamePlan plan, IProgress? progress = null, CancellationToken cancellationToken = default) => diff --git a/tests/Titano.Data.Tests/Archiving/MassRenameTests.cs b/tests/Titano.Data.Tests/Archiving/MassRenameTests.cs index 5cf3130a..c54ca153 100644 --- a/tests/Titano.Data.Tests/Archiving/MassRenameTests.cs +++ b/tests/Titano.Data.Tests/Archiving/MassRenameTests.cs @@ -105,6 +105,69 @@ public sealed class MassRenameTests(TestContext context) Assert.True(Directory.Exists(fx.Paths.FromRelative(other.Steps[0].ToFolder))); } + /// "trips" with photos of its own, "trips/day2" inside it and "trips/day2/dawn" inside that: three nested sequences. + private static async Task> NestedAsync(ArchiveFixture fx) + { + Photos.WriteSeries(Path.Combine(fx.Paths.Root, "trips"), Start, 2); + Photos.WriteSeries(Path.Combine(fx.Paths.Root, "trips", "day2"), Start.AddDays(1), 2, firstSeed: 10); + Photos.WriteSeries(Path.Combine(fx.Paths.Root, "trips", "day2", "dawn"), Start.AddDays(2), 2, firstSeed: 20); + await fx.ScanAsync(); + var locations = (await fx.Db.Sequences.ListLocationsAsync(fx.Archive.Id)).OrderBy(l => l.Folder, StringComparer.Ordinal).ToList(); + Assert.SequenceEqual(["trips", "trips/day2", "trips/day2/dawn"], locations.Select(l => l.Folder)); + return [.. locations.Select(l => l.Id)]; + } + + [Test] + public async Task SequencesInsideAMovedFolderAreInTheDryRunAndMoveWithIt() + { + await using var fx = await CreateAsync(context); + var ids = await NestedAsync(fx); + var before = await StateAsync(fx, ids); + + var plan = await fx.Service.PlanRenameAsync(fx.Archive.Id, [ids[0]], "moved/{date}", null, fx.Ct); + Assert.SequenceEqual(["moved/2026-09-28", "moved/2026-09-28/day2", "moved/2026-09-28/day2/dawn"], plan.Steps.Select(s => s.ToFolder)); + Assert.SequenceEqual([false, true, true], plan.Steps.Select(s => s.Carried)); + Assert.SequenceEqual(before, await StateAsync(fx, ids)); + + await fx.Service.ApplyRenameAsync(plan, null, fx.Ct); + Assert.SequenceEqual(Expected(plan, before), await StateAsync(fx, ids)); + Assert.Empty(RenameJournal.ListPending(fx.Paths)); + Assert.Equal(0, (await fx.ScanAsync()).Indexed); + Assert.Empty((await fx.Service.FindOrphansAsync(fx.Archive.Id, fx.Ct)).MissingSequences); + } + + [Test] + public async Task NestedSequencesMovedTogetherLeaveTheirFolderFirst() + { + await using var fx = await CreateAsync(context); + var ids = await NestedAsync(fx); + var before = await StateAsync(fx, ids); + + var plan = await fx.Service.PlanRenameAsync(fx.Archive.Id, ids, "moved/{date}", null, fx.Ct); + Assert.SequenceEqual([ids[2], ids[1], ids[0]], plan.Steps.Select(s => s.SequenceId)); + Assert.True(plan.Steps.All(s => !s.Carried)); + + await fx.Service.ApplyRenameAsync(plan, null, fx.Ct); + Assert.SequenceEqual(["moved/2026-09-28", "moved/2026-09-29", "moved/2026-09-30"], (await fx.Db.Sequences.ListLocationsAsync(fx.Archive.Id)) + .Select(l => l.Folder).Order(StringComparer.Ordinal)); + Assert.SequenceEqual(Expected(plan, before), await StateAsync(fx, ids)); + Assert.Equal(0, (await fx.ScanAsync()).Indexed); + } + + [Test] + public async Task AFolderInsideASequenceFolderIsRefused() + { + await using var fx = await CreateAsync(context); + var ids = await PopulateAsync(fx); + var before = await StateAsync(fx, ids); + + var into = await Assert.ThrowsAsync(() => fx.Service.PlanRenameAsync(fx.Archive.Id, [ids[1]], "inbox/a/{date}", null, fx.Ct)); + Assert.Equal("inbox/a", into.Folder); + var itself = await Assert.ThrowsAsync(() => fx.Service.PlanRenameAsync(fx.Archive.Id, [ids[0]], "inbox/a/{date}", null, fx.Ct)); + Assert.Equal("inbox/a/2026-09-28", itself.Target); + Assert.SequenceEqual(before, await StateAsync(fx, ids)); + } + /// Reports synchronously (Progress<T> would post to the thread pool). private sealed class SyncProgress(Action report) : IProgress {