Function migrate_targets

src/migration/orchestrator.rs:85–184

(
    targets: &[Box<dyn MigrationTarget>],
    resolver: &mut dyn AmbiguityResolver,
)

#[expect(clippy::result_large_err)]
pub fn migrate_targets(
    targets: &[Box<dyn MigrationTarget>],
    resolver: &mut dyn AmbiguityResolver,
) -> Result<MigrationReport, MigrationOrchestratorError> {
    let to_version = ConfigVersion::current();
    let mut pending = Vec::new();

    for target in targets {
        let path = target.path().to_path_buf();
        let target_name = target.name().to_string();
        let original =
            fs::read_to_string(&path).map_err(|source| MigrationOrchestratorError::ReadFile {
                path: path.clone(),
                source,
            })?;
        let detected = target.detect_version(&original).map_err(|source| {
            MigrationOrchestratorError::DetectVersion {
                target: target_name.clone(),
                source,
            }
        })?;
        let from_version = detected.unwrap_or_else(ConfigVersion::legacy_baseline);
        let output = target
            .migrate(&original, &from_version, &to_version, resolver)
            .map_err(|source| MigrationOrchestratorError::MigrateTarget {
                target: target_name.clone(),
                source,
            })?;

        target.validate(&output.content).map_err(|source| {
            MigrationOrchestratorError::ValidateTarget {
                target: target_name.clone(),
                source,
            }
        })?;

        pending.push(PendingMigration {
            target_name,
            path,
            from_version,
            to_version: to_version.clone(),
            changed: output.content != original,
            output,
            backup_path: None,
        });
    }

    let mut written = Vec::<(PathBuf, PathBuf)>::new();

    for entry in &mut pending {
        if !entry.changed {
            continue;
        }

        let backup_path = next_backup_path(&entry.path);
        fs::copy(&entry.path, &backup_path).map_err(|source| {
            MigrationOrchestratorError::BackupFile {
                path: entry.path.clone(),