Enum ChangeKind 

pub enum ChangeKind {
    Feat,
    Fix,
    Perf,
    Refactor,
    Docs,
    Test,
    Chore,
    Ci,
    Style,
    Build,
    Revert,
    Merge,
    Other,
}

What a conventional commit says it did.

The set is the one the repository’s own commit convention uses; a commit whose subject does not parse is ChangeKind::Other and still appears, because a changelog that silently drops what it cannot classify is a changelog that lies by omission.

Variants

Feat

A capability a person did not have before.

Fix

Behaviour that was wrong and is not any more.

Perf

Performance, with the behaviour unchanged.

Refactor

Structure, with the behaviour unchanged.

Docs

Documentation.

Test

Tests.

Chore

The build, the pipeline, the tooling.

Ci

Continuous integration.

Style

Formatting, with the behaviour unchanged.

Build

The build system or its dependencies.

Revert

A change that undoes another.

Merge

An integration: one line of work brought into another.

Not in the conventional-commit specification, and in this repository’s history 38 times and counting, because integration here is a deliberate act with a subject somebody writes — merge: bring origin/master into feature/x — and not the sentence git merge composes. Declaring it is what lets the validator hold those subjects to the same width and the same references as every other commit, instead of either refusing a convention this project practises or exempting it from being checked at all. The changelog never renders it: commits::in_range reads the log with --no-merges, so a merge commit is not a release entry however its subject is spelled.

Other

A commit whose subject does not parse as a conventional commit.

Implementations

impl ChangeKind

pub const WORDS: &'static [&'static str]

The type words, in the order Self::TABLE declares them.

use majordomus_cli::release::ChangeKind;
assert_eq!(ChangeKind::WORDS.first(), Some(&"feat"));
assert!(ChangeKind::WORDS.iter().all(|w| ChangeKind::parse(w) != ChangeKind::Other));

pub fn parse(word: &str) -> ChangeKind

The kind one conventional-commit type word names.

pub fn word(self) -> Option<&'static str>

The word this kind is written as, or None for ChangeKind::Other, which is not a type anybody writes.

The inverse of ChangeKind::parse over the one table, so the two cannot disagree about which words exist:

use majordomus_cli::release::model::ChangeKind;

assert_eq!(ChangeKind::parse("feat").word(), Some("feat"));
assert_eq!(ChangeKind::Perf.word(), Some("perf"));

// `Other` is what an unknown word parses to, and it is not itself a word: a
// validator quoting the vocabulary back must not offer it as something to type.
assert_eq!(ChangeKind::parse("nonsense"), ChangeKind::Other);
assert_eq!(ChangeKind::Other.word(), None);

// every word the vocabulary advertises round-trips through both directions
for word in ChangeKind::WORDS {
    assert_eq!(ChangeKind::parse(word).word(), Some(*word), "{word} round-trips");
}

pub fn heading(self) -> &'static str

The heading this kind is rendered under, and the order the headings appear in.

Ordered by what a reader of a changelog came for: what is new, what is fixed, what is faster, then the rest. Nothing is hidden — a section with no entries is simply absent.

pub fn rank(self) -> u8

Where the heading sorts.

Trait Implementations

impl Clone for ChangeKind

fn clone(&self) -> ChangeKind

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for ChangeKind

impl Debug for ChangeKind

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ChangeKind

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for ChangeKind

impl JsonSchema for ChangeKind

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 Ord for ChangeKind

fn cmp(&self, other: &ChangeKind) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for ChangeKind

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

fn partial_cmp(&self, other: &ChangeKind) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Serialize for ChangeKind

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 ChangeKind