cargo-generate 0.23.8

cargo, make me a project
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
122
123
124
125
126
127
128
129
130

use cargo_util_schemas::manifest::TomlManifest;
use std::{
    fs,
    path::{Path, PathBuf},
};

use anyhow::{anyhow, bail, Context, Result};
use log::warn;

#[derive(Debug, PartialEq)]
pub enum WorkspaceMemberStatus {
    Added(PathBuf),
    NoWorkspaceFound,
}

/// Add the given project to the workspace members list.
/// If there is no workspace project in the parent directories of the given path, do nothing.
pub fn add_to_workspace(member_path: &Path) -> Result<WorkspaceMemberStatus> {
    let Some(mut workspace) = Workspace::try_new(member_path)? else {
        return Ok(WorkspaceMemberStatus::NoWorkspaceFound);
    };
    let member = WorkspaceMember::try_new(member_path)?;
    workspace.add_member(member)?;
    workspace.save()?;

    Ok(WorkspaceMemberStatus::Added(workspace.cargo_toml_path))
}

struct Workspace {
    manifest: TomlManifest,
    cargo_toml_path: PathBuf,
}

impl Workspace {
    /// Try to find a workspace project in the parent directories of the given path.
    ///
    /// Returns `None` if no workspace project is found.
    pub fn try_new(member_path: &Path) -> Result<Option<Self>> {
        if let Some(parent) = member_path.parent() {
            let cargo_toml_path = parent.join("Cargo.toml");
            if cargo_toml_path.exists() {
                let content = fs::read_to_string(&cargo_toml_path)?;
                let manifest: TomlManifest = toml::from_str(&content)
                    .with_context(|| format!("Failed to parse {}", cargo_toml_path.display()))?;
                if manifest.workspace.is_some()
                    && manifest.workspace.as_ref().unwrap().members.is_some()
                {
                    return Ok(Some(Self {
                        manifest,
                        cargo_toml_path,
                    }));
                }
            }
        }

        Ok(None)
    }

    /// Add a new member to the workspace, if it is not already a member.
    /// The member list will be sorted alphabetically.
    pub fn add_member(&mut self, member: WorkspaceMember) -> Result<()> {
        let Some(workspace) = self.manifest.workspace.as_mut() else {
            bail!(
                "There is no workspace project at {}",
                self.cargo_toml_path.display()
            );
        };

        let Some(members) = workspace.members.as_mut() else {
            bail!("There are no workspace members yet defined.");
        };

        if members.contains(&member.name) {
            warn!(
                "Project `{}` is already a member of the workspace",
                member.name
            );
            return Ok(());
        }

        members.push(member.name.clone());
        members.sort();

        Ok(())
    }

    /// Save the updated manifest to disk.
    pub fn save(&self) -> Result<()> {
        let new_manifest = toml::to_string_pretty(&self.manifest)?;
        let cargo_toml_path = &self.cargo_toml_path;
        fs::write(cargo_toml_path, new_manifest)
            .with_context(|| format!("Failed to write {}", cargo_toml_path.display()))?;

        Ok(())
    }
}

struct WorkspaceMember {
    name: String,
}

impl WorkspaceMember {
    pub fn try_new(member_path: &Path) -> Result<Self> {
        let cargo_toml_path = member_path.join("Cargo.toml");
        let content = fs::read_to_string(&cargo_toml_path)
            .with_context(|| format!("Failed to read {}", cargo_toml_path.display()))?;
        let manifest: TomlManifest = toml::from_str(&content)
            .with_context(|| format!("Failed to parse {}", cargo_toml_path.display()))?;

        let pkg = manifest.package().ok_or_else(|| {
            anyhow!(
                "No [package] section found in Cargo.toml at {}",
                cargo_toml_path.display()
            )
        })?;

        let name = pkg
            .name
            .as_ref()
            .ok_or_else(|| {
                anyhow!(
                    "No `package.name` found in Cargo.toml at {}",
                    cargo_toml_path.display()
                )
            })?
            .to_string();

        Ok(Self { name })
    }
}