changen 0.1.10

Helper program to manage a changelog
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

use anyhow::bail;
use changelog::{ser::serialize_changelog, utils::DEFAULT_UNRELEASED, ChangeLog};

use crate::{
    config::MergeDevVersions,
    git_provider::DiffTags,
    repository::{try_detect_new_version, Repository},
};

pub fn release<R: Repository>(
    r: &R,
    mut changelog: ChangeLog,
    options: &crate::config::Release,
) -> anyhow::Result<(String, String)> {
    let crate::config::Release {
        file: _,
        version,
        previous_version,
        provider,
        repo,
        header,
        merge_dev_versions,
        omit_diff,
        stdout: _,
        force,
    } = options;

    let new_version = try_detect_new_version(r, version.clone())?;

    if changelog.releases.contains_key(&new_version) {
        if *force {
            changelog.releases.remove(&new_version);
            eprintln!("The release {} will be overwritten", new_version)
        } else {
            bail!(
                "Version {} already exist. Create a new tag or use the --version option. You can also use the --force option to override the existing release.",
                new_version
            );
        }
    };

    let mut prev_unreleased = changelog
        .unreleased
        .replace(DEFAULT_UNRELEASED.clone())
        .unwrap_or(DEFAULT_UNRELEASED.clone());

    prev_unreleased.title.version = new_version.to_string();

    if let Some(header) = header {
        match &prev_unreleased.header {
            Some(prev_header) => {
                prev_unreleased.header = Some(format!("{}\n\n{}", header, prev_header))
            }
            None => prev_unreleased.header = Some(header.clone()),
        }
    }

    if let Some(repo) = &repo {
        match provider.release_link(repo, &new_version.to_string()) {
            Ok(link) => {
                prev_unreleased.title.release_link = Some(link);
            }
            Err(e) => {
                eprintln!("{e}");
            }
        }
    }

    match merge_dev_versions {
        MergeDevVersions::Yes | MergeDevVersions::Auto
            if let Some(new_version_semver) = new_version.version_opt()
                && new_version_semver.pre.is_empty() =>
        {
            let dev_releases = changelog
                .releases
                .extract_if(|k, _| {
                    k.version_opt()
                        .map(|k| {
                            k.major == new_version_semver.major
                                && k.minor == new_version_semver.minor
                                && k.patch == new_version_semver.patch
                        })
                        .unwrap_or(false)
                })
                .collect::<Vec<_>>();

            for (_, dev_release) in dev_releases {
                prev_unreleased
                    .insert_release_notes(dev_release.note_sections.into_iter().map(|(_, sec)| sec))
            }
        }
        _ => {}
    }

    let previous_version = previous_version
        .clone()
        .or_else(|| changelog.last_version());

    let diff_tags = DiffTags::new(new_version, previous_version)?;

    if !omit_diff {
        let link = if let Some(repo) = &repo {
            match provider.diff_link(repo, &diff_tags) {
                Ok(link) => Some(link),
                Err(e) => {
                    eprintln!("{e}");
                    None
                }
            }
        } else {
            None
        };

        if let Some(link) = link {
            let line = format!("_Full Changelog: {link}_");

            match &mut prev_unreleased.footer {
                Some(footer) => {
                    footer.push_str("\n\n");
                    footer.push_str(&line);
                }
                None => {
                    prev_unreleased.footer = Some(line);
                }
            }
        }
    }

    changelog
        .releases
        .insert(diff_tags.new.clone(), prev_unreleased);

    debug!("release: serialize changelog: {:?}", changelog);

    changelog.sanitize(&changelog::fmt::Options::default());

    let output = serialize_changelog(&changelog, &changelog::ser::Options::default());

    Ok((diff_tags.new.to_string(), output))
}