release_plz_core 0.36.13

Update version and changelog based on semantic versioning and conventional commits
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
131
132
133
134
135
136
137
138
139
140
141
142
143
144

use cargo_metadata::{Package, semver::Version};
use tracing::warn;

use crate::{UpdateResult, semver_check::SemverCheck};

use super::ReleaseInfo;

pub type PackagesToUpdate = Vec<(Package, UpdateResult)>;

#[derive(Clone, Debug, Default)]
pub struct PackagesUpdate {
    updates: PackagesToUpdate,
    /// New workspace version. If None, the workspace version is not updated.
    /// See cargo [docs](https://doc.rust-lang.org/cargo/reference/workspaces.html#root-package).
    workspace_version: Option<Version>,
}

impl PackagesUpdate {
    pub fn new(updates: PackagesToUpdate) -> Self {
        Self {
            updates,
            workspace_version: None,
        }
    }

    pub fn with_workspace_version(&mut self, workspace_version: Version) {
        self.workspace_version = Some(workspace_version);
    }

    pub fn updates(&self) -> &[(Package, UpdateResult)] {
        &self.updates
    }

    pub fn updates_clone(&self) -> PackagesToUpdate {
        self.updates.clone()
    }

    pub fn updates_mut(&mut self) -> &mut PackagesToUpdate {
        &mut self.updates
    }

    pub fn workspace_version(&self) -> Option<&Version> {
        self.workspace_version.as_ref()
    }

    pub fn summary(&self) -> String {
        let updates = self.updates_summary();
        let breaking_changes = self.breaking_changes();
        format!("{updates}\n{breaking_changes}")
    }

    fn updates_summary(&self) -> String {
        self.updates
            .iter()
            .map(|(package, update)| {
                // Use registry_version as previous_version when available
                // (version already bumped case), otherwise use package.version
                let previous_version = update.registry_version.as_ref().unwrap_or(&package.version);
                if previous_version == &update.version {
                    format!("\n* `{}`: {}", package.name, update.version)
                } else {
                    format!(
                        "\n* `{}`: {} -> {}{}",
                        package.name,
                        previous_version,
                        update.version,
                        update.semver_check.outcome_str()
                    )
                }
            })
            .collect()
    }

    pub fn breaking_changes(&self) -> String {
        self.updates
            .iter()
            .map(|(package, update)| match &update.semver_check {
                SemverCheck::Incompatible(incompatibilities) => {
                    format!(
                        "\n### ⚠️ `{}` breaking changes\n\n```{}```\n",
                        package.name, incompatibilities
                    )
                }
                SemverCheck::Compatible | SemverCheck::Skipped => String::new(),
            })
            .collect()
    }

    /// Return info about releases of the updated packages
    pub fn releases(&self) -> Vec<ReleaseInfo> {
        self.updates
            .iter()
            .map(|(package, update)| {
                let default_result = match &update.new_changelog_entry {
                    Some(entry) => (None, Some(entry.clone())),
                    None => (None, None),
                };
                let (changelog_title, changelog_notes) = match update.last_changes() {
                    Err(e) => {
                        warn!(
                            "can't determine changes in changelog of package {}: {e:?}",
                            package.name
                        );
                        default_result
                    }
                    Ok(Some(c)) => (Some(c.title().to_string()), Some(c.notes().to_string())),
                    Ok(None) => {
                        warn!(
                            "no changes detected in changelog of package {}",
                            package.name
                        );
                        default_result
                    }
                };

                let (semver_check, breaking_changes) = match &update.semver_check {
                    SemverCheck::Incompatible(incompatibilities) => {
                        ("incompatible", Some(incompatibilities.clone()))
                    }
                    SemverCheck::Compatible => ("compatible", None),
                    SemverCheck::Skipped => ("skipped", None),
                };

                // Use registry_version as previous_version when available
                // (version already bumped case), otherwise use package.version
                let previous_version = update
                    .registry_version
                    .as_ref()
                    .unwrap_or(&package.version)
                    .to_string();

                ReleaseInfo {
                    package: package.name.to_string(),
                    title: changelog_title,
                    changelog: changelog_notes,
                    next_version: update.version.to_string(),
                    previous_version,
                    breaking_changes,
                    semver_check: semver_check.to_string(),
                }
            })
            .collect()
    }
}