emplace 0.3.10

Command-line tool to mirror installed software on multiple machines.
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

/// Automatic migration for version <= 0.2.
pub mod zero_two {
    use crate::{
        package::{Package, Packages},
        package_manager::*,
    };
    use ron::de;
    use serde::{Deserialize, Serialize};

    #[derive(Debug, Serialize, Deserialize, Eq, PartialEq)]
    enum OldPackageManager {
        Apt,
        Cargo,
        Pacman,
        Yay,
        Rua,
        Snap,
        Chocolatey,
        Scoop,
        Pip,
        Pip3,
        Npm,
        Nix,
        // Mapped to Rustup
        RustupComponent,
        // Mapped to Pip
        PipUser,
        // Mapped to Pip3
        Pip3User,
    }

    #[derive(Debug, Serialize, Deserialize)]
    struct OldPackage {
        source: OldPackageManager,
        name: String,
        #[serde(skip)]
        pub(crate) package_name: Option<String>,
    }

    #[derive(Debug, Serialize, Deserialize)]
    struct OldPackages(Vec<OldPackage>);

    /// Attempt to migrate a version 0.2 package list to the current version.
    pub fn try_migrate(contents: &str) -> Option<Packages> {
        // Parse the ron and return if it fails
        let old_packages: OldPackages = de::from_str(contents).ok()?;

        println!("Migrating from Emplace 0.2");

        Some(
            old_packages
                .0
                .into_iter()
                .map(|old_package| {
                    // Map PipUser to Pip
                    if old_package.source == OldPackageManager::PipUser {
                        return Package::new(
                            PackageManager::from(Pip),
                            old_package.name,
                            vec!["--user".into()],
                        );
                    }
                    // Map Pip3User to Pip3
                    if old_package.source == OldPackageManager::Pip3User {
                        return Package::new(
                            PackageManager::from(Pip3),
                            old_package.name,
                            vec!["--user".into()],
                        );
                    }

                    let source = match old_package.source {
                        OldPackageManager::Apt => PackageManager::from(Apt),
                        OldPackageManager::Cargo => PackageManager::from(Cargo),
                        OldPackageManager::Pacman => PackageManager::from(Pacman),
                        OldPackageManager::Yay => PackageManager::from(Yay),
                        OldPackageManager::Rua => PackageManager::from(Rua),
                        OldPackageManager::Snap => PackageManager::from(Snap),
                        OldPackageManager::Chocolatey => PackageManager::from(Chocolatey),
                        OldPackageManager::Scoop => PackageManager::from(Scoop),
                        OldPackageManager::Pip => PackageManager::from(Pip),
                        OldPackageManager::Pip3 => PackageManager::from(Pip3),
                        OldPackageManager::Npm => PackageManager::from(Npm),
                        OldPackageManager::Nix => PackageManager::from(Nix),
                        // Rename RustupComponent to Rustup
                        OldPackageManager::RustupComponent => PackageManager::from(Rustup),
                        _ => unreachable!(),
                    };

                    if old_package.name.starts_with("--git") {
                        // Convert --git names to flags
                        return Package::new(
                            source,
                            old_package.name.split_ascii_whitespace().skip(1).collect(),
                            vec!["--git".into()],
                        );
                    }

                    Package::new(source, old_package.name, vec![])
                })
                .collect::<Vec<Package>>()
                .into(),
        )
    }
}