@owenlamont/ryl 0.4.1

package/src/migrate.rs

@@ -0,0 +1,233 @@
+use std::collections::HashMap;
+use std::fs;
+use std::path::{Path, PathBuf};
+
+use ignore::WalkBuilder;
+
+use crate::config::{Overrides, discover_config};
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum WriteMode {
+    Preview,
+    Write,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum OutputMode {
+    SummaryOnly,
+    IncludeToml,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum SourceCleanup {
+    Keep,
+    Delete,
+    RenameSuffix(String),
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct MigrateOptions {
+    pub root: PathBuf,
+    pub write_mode: WriteMode,
+    pub output_mode: OutputMode,
+    pub cleanup: SourceCleanup,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct MigrationEntry {
+    pub source: PathBuf,
+    pub target: PathBuf,
+    pub toml: String,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct MigrateResult {
+    pub entries: Vec<MigrationEntry>,
+    pub cleanup_only_sources: Vec<PathBuf>,
+    pub warnings: Vec<String>,
+}
+
+#[derive(Debug, Default)]
+struct MigrationPlan {
+    entries: Vec<MigrationEntry>,
+    cleanup_only_sources: Vec<PathBuf>,
+    warnings: Vec<String>,
+}
+
+/// Apply write + cleanup actions for already planned migration entries.
+///
+/// # Errors
+/// Returns an error if writing targets or requested source cleanup fails.
+pub fn apply_migration_entries(
+    entries: &[MigrationEntry],
+    cleanup_only_sources: &[PathBuf],
+    cleanup: &SourceCleanup,
+) -> Result<(), String> {
+    let apply_cleanup = |source: &Path| -> Result<(), String> {
+        match cleanup {
+            SourceCleanup::Keep => {}
+            SourceCleanup::Delete => {
+                fs::remove_file(source).map_err(|err| {
+                    format!(
+                        "failed to delete migrated source config {}: {err}",
+                        source.display()
+                    )
+                })?;
+            }
+            SourceCleanup::RenameSuffix(suffix) => {
+                let source_name = source.file_name().map_or_else(String::new, |name| {
+                    name.to_string_lossy().to_string()
+                });
+                let renamed = source.with_file_name(format!("{source_name}{suffix}"));
+                fs::rename(source, &renamed).map_err(|err| {
+                    format!(
+                        "failed to rename migrated source config {} to {}: {err}",
+                        source.display(),
+                        renamed.display()
+                    )
+                })?;
+            }
+        }
+        Ok(())
+    };
+
+    for entry in entries {
+        fs::write(&entry.target, &entry.toml).map_err(|err| {
+            format!(
+                "failed to write migrated config {}: {err}",
+                entry.target.display()
+            )
+        })?;
+    }
+
+    for source in entries
+        .iter()
+        .map(|entry| &entry.source)
+        .chain(cleanup_only_sources.iter())
+    {
+        apply_cleanup(source)?;
+    }
+
+    Ok(())
+}
+
+fn yaml_config_rank(path: &Path) -> usize {
+    match path.file_name().and_then(|name| name.to_str()) {
+        Some(".yamllint") => 0,
+        Some(".yamllint.yaml") => 1,
+        _ => 2,
+    }
+}
+
+fn is_legacy_yaml_config_path(path: &Path) -> bool {
+    path.file_name()
+        .and_then(|name| name.to_str())
+        .is_some_and(|name| {
+            name == ".yamllint" || name == ".yamllint.yaml" || name == ".yamllint.yml"
+        })
+}
+
+fn discover_legacy_yaml_configs(root: &Path) -> Vec<PathBuf> {
+    if root.is_file() {
+        return if is_legacy_yaml_config_path(root) {
+            vec![root.to_path_buf()]
+        } else {
+            Vec::new()
+        };
+    }
+
+    let walker = WalkBuilder::new(root)
+        .hidden(false)
+        .ignore(false)
+        .git_ignore(false)
+        .git_global(false)
+        .git_exclude(false)
+        .follow_links(false)
+        .build();
+
+    walker
+        .flatten()
+        .map(|entry| entry.path().to_path_buf())
+        .filter(|path| path.is_file() && is_legacy_yaml_config_path(path))
+        .collect()
+}
+
+fn build_migration_entries(root: &Path) -> Result<MigrationPlan, String> {
+    let mut grouped: HashMap<PathBuf, Vec<PathBuf>> = HashMap::new();
+    for path in discover_legacy_yaml_configs(root) {
+        let parent = path.parent().unwrap_or(Path::new(".")).to_path_buf();
+        grouped.entry(parent).or_default().push(path);
+    }
+
+    let mut plan = MigrationPlan::default();
+    let mut directories: Vec<PathBuf> = grouped.keys().cloned().collect();
+    directories.sort();
+
+    for dir in directories {
+        let mut paths = grouped
+            .remove(&dir)
+            .expect("directory key should exist in grouped map");
+        paths.sort_by(|left, right| {
+            yaml_config_rank(left)
+                .cmp(&yaml_config_rank(right))
+                .then(left.cmp(right))
+        });
+        let primary = paths
+            .first()
+            .cloned()
+            .expect("at least one config path should exist per grouped directory");
+        for ignored in paths.iter().skip(1) {
+            plan.cleanup_only_sources.push(ignored.clone());
+            plan.warnings.push(format!(
+                "warning: skipping lower-precedence config {} in favor of {}",
+                ignored.display(),
+                primary.display()
+            ));
+        }
+
+        let ctx = discover_config(
+            &[],
+            &Overrides {
+                config_file: Some(primary.clone()),
+                config_data: None,
+            },
+        )?;
+        let rendered = ctx.config.to_toml_string()?;
+        let toml = format!("{}\n", rendered.trim_end());
+        plan.entries.push(MigrationEntry {
+            source: primary,
+            target: dir.join(".ryl.toml"),
+            toml,
+        });
+    }
+
+    Ok(plan)
+}
+
+/// Build and optionally apply YAML-to-TOML config migration.
+///
+/// # Errors
+/// Returns an error if migration planning fails or file operations fail in write mode.
+pub fn migrate_configs(options: &MigrateOptions) -> Result<MigrateResult, String> {
+    if !options.root.exists() {
+        return Err(format!(
+            "error: migrate root does not exist: {}",
+            options.root.display()
+        ));
+    }
+
+    let plan = build_migration_entries(&options.root)?;
+    if options.write_mode == WriteMode::Write {
+        apply_migration_entries(
+            &plan.entries,
+            &plan.cleanup_only_sources,
+            &options.cleanup,
+        )?;
+    }
+
+    Ok(MigrateResult {
+        entries: plan.entries,
+        cleanup_only_sources: plan.cleanup_only_sources,
+        warnings: plan.warnings,
+    })
+}