Struct Commit 

pub struct Commit<'a> {
    pub body: Option<&'a str>,
    pub desc: &'a str,
    pub footer: Vec<Footer<'a>>,
    pub is_breaking_change: bool,
    pub scope: Option<&'a str>,
    pub ty: &'a str,
}

A commit message.

As per the specification, a commit message is made out of a mandatory description, an optional body and 0..n optional footers. The different sections are separated by an empty newline. Footers can be each separated with a newline, however, this is not needed.

Example

feat(some scope): a short and concise description

This is a longer body message. It can wrapped around
and be put onto multiple lines.

This is still part of the body.

Fixes #123
PR-close #124
Signed-off-by: SirWindfield

Fields

body: Option<&'a str>

The optional body.

desc: &'a str

The mandatory description.

footer: Vec<Footer<'a>>

A list of footers. Empty when none are part of the commit message.

is_breaking_change: bool

Set if the commit is a breaking change.

scope: Option<&'a str>

The optional scope.

ty: &'a str

The mandatory type.

Types other than feat and fix are optional. For more information, please take a look at the specification, paragraphs 1-3.

Implementations

impl<'a> Commit<'a>

pub fn new() -> Commit<'a>

Creates a default commit.

pub fn from( ty: &'a str, scope: Option<&'a str>, desc: &'a str, body: Option<&'a str>, is_breaking_change: bool, footer: Vec<Footer<'a>>, ) -> Commit<'a>

Creates a commit with the given values.

Trait Implementations

impl<'a> Clone for Commit<'a>

fn clone(&self) -> Commit<'a>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'a> Debug for Commit<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<'a> Default for Commit<'a>

fn default() -> Commit<'a>

Returns the “default value” for a type.

impl<'a> Hash for Commit<'a>

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<'a> PartialEq for Commit<'a>

fn eq(&self, other: &Commit<'a>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a> Eq for Commit<'a>

impl<'a> StructuralPartialEq for Commit<'a>