ferrous-forge 1.9.6

System-wide Rust development standards enforcer
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121

//! Edition migration assistance

mod backup;
mod cargo_ops;
mod code_migration;
mod testing;
/// Data types for migration options, results, and steps.
pub mod types;

use crate::Result;
use std::path::{Path, PathBuf};

use super::Edition;
pub use types::{
    MigrationOptions, MigrationResult, MigrationRule, MigrationStatus, MigrationStep, TestResults,
};

/// Edition migrator for upgrading projects
pub struct EditionMigrator {
    project_path: PathBuf,
    backup_dir: Option<PathBuf>,
}

impl EditionMigrator {
    /// Create a new edition migrator
    pub fn new(project_path: impl AsRef<Path>) -> Self {
        Self {
            project_path: project_path.as_ref().to_path_buf(),
            backup_dir: None,
        }
    }

    /// Set backup directory
    pub fn with_backup(mut self, backup_dir: impl AsRef<Path>) -> Self {
        self.backup_dir = Some(backup_dir.as_ref().to_path_buf());
        self
    }

    /// Migrate project to target edition
    ///
    /// # Errors
    ///
    /// Returns an error if the current edition cannot be detected, backup
    /// creation fails, or any migration step fails.
    pub async fn migrate(
        &self,
        target_edition: Edition,
        options: MigrationOptions,
    ) -> Result<MigrationResult> {
        let mut result = MigrationResult::default();

        // Check if migration is needed
        if let Some(result) = self.check_migration_needed(target_edition).await? {
            return Ok(result);
        }

        result.status = MigrationStatus::InProgress;

        // Execute migration steps
        self.execute_migration_steps(target_edition, &options, &mut result)
            .await?;

        result.status = MigrationStatus::Completed;
        Ok(result)
    }

    /// Check if migration is needed
    async fn check_migration_needed(
        &self,
        target_edition: Edition,
    ) -> Result<Option<MigrationResult>> {
        let manifest_path = self.project_path.join("Cargo.toml");
        let current_edition = super::detect_edition(&manifest_path).await?;

        if current_edition >= target_edition {
            let result = MigrationResult {
                status: MigrationStatus::AlreadyUpToDate,
                ..Default::default()
            };
            return Ok(Some(result));
        }

        Ok(None)
    }

    /// Execute all migration steps based on options
    async fn execute_migration_steps(
        &self,
        target_edition: Edition,
        options: &MigrationOptions,
        result: &mut MigrationResult,
    ) -> Result<()> {
        if options.create_backup {
            self.create_backup(result).await?;
        }

        self.update_cargo_toml(target_edition, result).await?;

        if options.apply_code_migrations {
            self.apply_code_migrations(target_edition, result).await?;
        }

        if options.update_dependencies {
            self.update_dependencies(result).await?;
        }

        if options.format_code {
            self.apply_rustfmt(result).await?;
        }

        if options.run_tests {
            self.run_tests(result).await?;
        }

        if options.commit_changes {
            self.commit_changes(result).await?;
        }

        Ok(())
    }
}