Struct CommitHeader 

pub struct CommitHeader {
    pub word: String,
    pub kind: ChangeKind,
    pub scope: Option<String>,
    pub breaking: bool,
    pub subject: String,
}

The header of a commit message: its first line, taken apart.

word is the type as the author wrote it and kind is what that word names; they differ exactly when the word is not one of the eleven the convention defines, and keeping both is what lets a reader see wip(site): halfway through as its author typed it while a judge still reports that wip is not a type.

use majordomus_cli::commit::CommitHeader;
use majordomus_cli::release::ChangeKind;
let h = CommitHeader::parse("fix(plan): the fingerprint names what moved");
assert_eq!(h.word, "fix");
assert_eq!(h.kind, ChangeKind::Fix);
assert_eq!(h.scope.as_deref(), Some("plan"));
assert!(!h.breaking);
assert_eq!(h.subject, "the fingerprint names what moved");

Fields

word: String

The type as written: feat, fix, wip, or the empty string when the subject carries no type: head at all.

kind: ChangeKind

What Self::word names; ChangeKind::Other for a word the convention does not define, and for a subject with no head.

scope: Option<String>

The parenthesised scope, when there is one.

breaking: bool

Whether the head carried the ! that marks a breaking change. The BREAKING CHANGE: trailer is a property of the body and is read by crate::commit::CommitMessage.

subject: String

What the commit says it did. For a header that does not parse this is the whole first line, unchanged, and for an unknown type word it keeps the word: nothing that the author wrote is dropped on the way through.

Implementations

impl CommitHeader

pub fn parse(subject: &str) -> CommitHeader

Read one subject line. Never fails; see the module documentation for why.

use majordomus_cli::commit::CommitHeader;
// a conventional subject comes apart
assert_eq!(CommitHeader::parse("docs: one line").subject, "one line");
// and one that is not is carried whole rather than split at a colon in the sentence
let m = CommitHeader::parse("Merge branch 'x' of host: into y");
assert_eq!(m.word, "");
assert_eq!(m.subject, "Merge branch 'x' of host: into y");

pub fn is_conventional(&self) -> bool

Whether this header is a conventional commit: a type word the convention defines, followed by an optional scope, an optional !, : , and a subject.

use majordomus_cli::commit::CommitHeader;
assert!(CommitHeader::parse("docs: the page the recipes cite").is_conventional());
assert!(!CommitHeader::parse("update stuff").is_conventional());
assert!(!CommitHeader::parse("wip(site): halfway").is_conventional());

pub fn render(&self) -> String

Render a header back to the line it came from.

The round trip is exact for every conventional header, which is the property that lets a planner build a header, a validator judge the rendered line, and both be talking about the same commit.

use majordomus_cli::commit::CommitHeader;
for line in ["feat(commit)!: derived", "fix: one thing", "perf(http): fewer reads"] {
    assert_eq!(CommitHeader::parse(line).render(), line);
}

Trait Implementations

impl Clone for CommitHeader

fn clone(&self) -> CommitHeader

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for CommitHeader

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for CommitHeader

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for CommitHeader

impl JsonSchema for CommitHeader

fn schema_name() -> Cow<'static, str>

The name of the generated JSON Schema.

fn schema_id() -> Cow<'static, str>

Returns a string that uniquely identifies the schema produced by this type.

fn json_schema(generator: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type.

fn inline_schema() -> bool

Whether JSON Schemas generated for this type should be included directly in parent schemas, rather than being re-used where possible using the $ref keyword.

impl PartialEq for CommitHeader

fn eq(&self, other: &CommitHeader) -> 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 Serialize for CommitHeader

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for CommitHeader