ploys 0.6.0

A utility to manage projects, packages, releases and deployments.
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

mod request;

use tracing::{info, info_span};

use crate::repository::Remote;

pub use self::request::{ReleaseRequest, ReleaseRequestBuilder};

use super::{Package, Project};

/// The package release.
pub struct Release {
    id: u64,
    name: String,
    notes: crate::changelog::Release,
}

impl Release {
    /// Gets the release id.
    pub fn id(&self) -> u64 {
        self.id
    }

    /// Gets the release name.
    pub fn name(&self) -> &str {
        &self.name
    }

    /// Gets the release notes.
    pub fn notes(&self) -> &crate::changelog::Release {
        &self.notes
    }
}

/// The package release builder.
pub struct ReleaseBuilder<'a, T> {
    project: &'a Project<T>,
    package: Package<T>,
}

impl<'a, T> ReleaseBuilder<'a, T> {
    /// Constructs a new release builder.
    pub(crate) fn new(project: &'a Project<T>, package: Package<T>) -> Self {
        Self { project, package }
    }
}

impl<T> ReleaseBuilder<'_, T>
where
    T: Remote,
{
    /// Finishes the release.
    pub fn finish(self) -> Result<Release, T::Error> {
        let sha = self.project.repository.sha()?;

        let version = self.package.version();

        let span = info_span!("release", package = self.package.name(), %version);
        let _enter = span.enter();

        info!("Creating release");

        let prerelease = !version.pre.is_empty();
        let latest = self.package.is_primary() && !prerelease;

        let tag = match self.package.is_primary() {
            true => version.to_string(),
            false => format!("{}-{version}", self.package.name()),
        };

        let name = match self.package.is_primary() {
            true => version.to_string(),
            false => format!("{} {version}", self.package.name()),
        };

        let changelog = self.package.changelog();
        let release = changelog
            .as_ref()
            .and_then(|changelog| changelog.get_release(version.to_string()));

        let release = match release {
            Some(release) => release.to_owned(),
            None => self.package.build_release_notes(&version)?,
        };

        let body = format!("{release:#}")
            .lines()
            .skip(2)
            .collect::<Vec<_>>()
            .join("\n");

        let id = self
            .project
            .repository
            .create_release(&tag, &sha, &name, &body, prerelease, latest)?;

        info!(id, "Created release");

        Ok(Release {
            id,
            name,
            notes: release,
        })
    }
}