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

use std::fmt::{self, Display};

/// The git revision.
#[derive(Clone, Debug, Default, PartialEq, Eq, Hash)]
pub enum Revision {
    #[default]
    Head,
    Sha(String),
    Reference(Reference),
}

impl Revision {
    /// Constructs a new HEAD revision.
    pub fn head() -> Self {
        Self::Head
    }

    /// Constructs a new SHA revision.
    pub fn sha(sha: impl Into<String>) -> Self {
        Self::Sha(sha.into())
    }

    /// Constructs a new branch revision.
    pub fn branch(branch: impl Into<String>) -> Self {
        Self::Reference(Reference::Branch(branch.into()))
    }

    /// Constructs a new tag revision.
    pub fn tag(tag: impl Into<String>) -> Self {
        Self::Reference(Reference::Tag(tag.into()))
    }
}

impl Display for Revision {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Self::Head => write!(f, "HEAD"),
            Self::Sha(sha) => write!(f, "{sha}"),
            Self::Reference(reference) => write!(f, "refs/{reference}"),
        }
    }
}

impl From<Reference> for Revision {
    fn from(reference: Reference) -> Self {
        Self::Reference(reference)
    }
}

/// The git reference.
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub enum Reference {
    Branch(String),
    Tag(String),
}

impl Reference {
    /// Constructs a new branch reference.
    pub fn branch(branch: impl Into<String>) -> Self {
        Self::Branch(branch.into())
    }

    /// Constructs a new tag reference.
    pub fn tag(tag: impl Into<String>) -> Self {
        Self::Tag(tag.into())
    }
}

impl Display for Reference {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Self::Branch(branch) => write!(f, "heads/{branch}"),
            Self::Tag(tag) => write!(f, "tags/{tag}"),
        }
    }
}