Enum Lint

pub enum Lint {
    DuplicatedTrailers,
    PivotalTrackerIdMissing,
    JiraIssueKeyMissing,
    GitHubIdMissing,
    SubjectNotSeparateFromBody,
    SubjectLongerThan72Characters,
    SubjectNotCapitalized,
    SubjectEndsWithPeriod,
    BodyWiderThan72Characters,
    NotConventionalCommit,
    NotEmojiLog,
}

The lints that are supported

Variants

DuplicatedTrailers

Check for duplicated trailers

Examples

Passing

use mit_commit::CommitMessage;
use mit_lint::Lint;

let message: &str = "An example commit

This is an example commit without any duplicate trailers
"
.into();
let actual = Lint::DuplicatedTrailers.lint(&CommitMessage::from(message));
assert!(actual.is_none(), "Expected None, found {:?}", actual);

Erring

use mit_commit::CommitMessage;
use mit_lint::{Code, Lint, Problem};

let message: &str = "An example commit

This is an example commit without any duplicate trailers

Signed-off-by: Billie Thompson <email@example.com>
Signed-off-by: Billie Thompson <email@example.com>
Co-authored-by: Billie Thompson <email@example.com>
Co-authored-by: Billie Thompson <email@example.com>
"
.into();
let expected = Some(Problem::new(
    "Your commit message has duplicated trailers".into(),
    "These are normally added accidentally when you\'re rebasing or amending to a \
     commit, sometimes in the text editor, but often by git hooks.\n\nYou can fix \
     this by deleting the duplicated \"Co-authored-by\", \"Signed-off-by\" fields"
        .into(),
    Code::DuplicatedTrailers,
    &message.into(),
    Some(vec![
        ("Duplicated `Co-authored-by`".to_string(), 231, 51),
        ("Duplicated `Signed-off-by`".to_string(), 128, 50),
    ]),
    Some(
        "https://git-scm.com/docs/githooks#_commit_msg"
            .parse()
            .unwrap(),
    ),
));
let actual = Lint::DuplicatedTrailers.lint(&CommitMessage::from(message));
assert_eq!(
    actual, expected,
    "Expected {:?}, found {:?}",
    expected, actual
);

PivotalTrackerIdMissing

Check for a missing pivotal tracker id

Examples

Passing

use mit_commit::CommitMessage;
use mit_lint::Lint;

let message: &str = "An example commit [fixes #12345678]
"
.into();
let actual = Lint::PivotalTrackerIdMissing.lint(&CommitMessage::from(message));
assert!(actual.is_none(), "Expected None, found {:?}", actual);

Erring

use mit_commit::CommitMessage;
use mit_lint::{Code, Lint, Problem};

let message: &str = "An example commit

This is an example commit
"

.into();
let expected = Some(Problem::new(
    "Your commit message is missing a Pivotal Tracker ID".into(),
    "It's important to add the ID because it allows code to be linked back to the stories it was done for, it can provide a chain of custody for code for audit purposes, and it can give future explorers of the codebase insight into the wider organisational need behind the change. We may also use it for automation purposes, like generating changelogs or notification emails.\n\nYou can fix this by adding the Id in one of the styles below to the commit message\n[Delivers #12345678]\n[fixes #12345678]\n[finishes #12345678]\n[#12345884 #12345678]\n[#12345884,#12345678]\n[#12345678],[#12345884]\nThis will address [#12345884]"
        .into(),
    Code::PivotalTrackerIdMissing,
    &message.into(),
    Some(vec![("No Pivotal Tracker ID".to_string(), 19, 25)]),
    Some("https://www.pivotaltracker.com/help/api?version=v5#Tracker_Updates_in_SCM_Post_Commit_Hooks".parse().unwrap()),
));
let actual = Lint::PivotalTrackerIdMissing.lint(&CommitMessage::from(message));
assert_eq!(
    actual, expected,
    "Expected {:?}, found {:?}",
    expected, actual
);

JiraIssueKeyMissing

Check for a missing jira issue key

Examples

Passing

use mit_commit::CommitMessage;
use mit_lint::Lint;

let message: &str = "An example commit

Relates-to: JRA-123
"
.into();
let actual = Lint::JiraIssueKeyMissing.lint(&CommitMessage::from(message));
assert!(actual.is_none(), "Expected None, found {:?}", actual);

Erring

use mit_commit::CommitMessage;
use mit_lint::{Code, Lint, Problem};

let message: &str = "An example commit

This is an example commit
"

.into();
let expected = Some(Problem::new(
    "Your commit message is missing a JIRA Issue Key".into(),
    "It's important to add the issue key because it allows us to link code back to the motivations for doing it, and in some cases provide an audit trail for compliance purposes.\n\nYou can fix this by adding a key like `JRA-123` to the commit message"
        .into(),
    Code::JiraIssueKeyMissing,&message.into(),
    Some(vec![("No JIRA Issue Key".to_string(), 19, 25)]),
    Some("https://support.atlassian.com/jira-software-cloud/docs/what-is-an-issue/#Workingwithissues-Projectkeys".parse().unwrap()),
));
let actual = Lint::JiraIssueKeyMissing.lint(&CommitMessage::from(message));
assert_eq!(
    actual, expected,
    "Expected {:?}, found {:?}",
    expected, actual
);

GitHubIdMissing

Check for a missing github id

Examples

Passing

use mit_commit::CommitMessage;
use mit_lint::Lint;

let message: &str = "An example commit

Relates-to: AnOrganisation/git-mit#642
"
.into();
let actual = Lint::GitHubIdMissing.lint(&CommitMessage::from(message));
assert!(actual.is_none(), "Expected None, found {:?}", actual);

Erring

use mit_commit::CommitMessage;
use mit_lint::{Code, Lint, Problem};

let message: &str = "An example commit

This is an example commit
"

.into();
let expected = Some(Problem::new(
     "Your commit message is missing a GitHub ID".into(),
    "It's important to add the issue ID because it allows us to link code back to the motivations for doing it, and because we can help people exploring the repository link their issues to specific bits of code.\n\nYou can fix this by adding a ID like the following examples:\n\n#642\nGH-642\nAnUser/git-mit#642\nAnOrganisation/git-mit#642\nfixes #642\n\nBe careful just putting '#642' on a line by itself, as '#' is the default comment character"
        .into(),
    Code::GitHubIdMissing,&message.into(),Some(vec![("No GitHub ID".to_string(), 19, 25)]),
Some("https://docs.github.com/en/github/writing-on-github/working-with-advanced-formatting/autolinked-references-and-urls#issues-and-pull-requests".parse().unwrap()),
));
let actual = Lint::GitHubIdMissing.lint(&CommitMessage::from(message));
assert_eq!(
    actual, expected,
    "Expected {:?}, found {:?}",
    expected, actual
);

SubjectNotSeparateFromBody

Subject being not being seperated from the body

Examples

Passing

use mit_commit::CommitMessage;
use mit_lint::Lint;

let message: &str = "An example commit

Some Body Content
"
.into();
let actual = Lint::SubjectNotSeparateFromBody.lint(&CommitMessage::from(message));
assert!(actual.is_none(), "Expected None, found {:?}", actual);

Erring

use mit_commit::CommitMessage;
use mit_lint::{Code, Lint, Problem};

let message: &str = "An example commit
This is an example commit
"
.into();
let expected = Some(Problem::new(
      "Your commit message is missing a blank line between the subject and the body".into(),
    "Most tools that render and parse commit messages, expect commit messages to be in the form of subject and body. This includes git itself in tools like git-format-patch. If you don't include this you may see strange behaviour from git and any related tools.\n\nTo fix this separate subject from body with a blank line"
        .into(),
    Code::SubjectNotSeparateFromBody,&message.into(),
    Some(vec![("Missing blank line".to_string(), 18, 25)]),
    Some("https://git-scm.com/book/en/v2/Distributed-Git-Contributing-to-a-Project#_commit_guidelines".parse().unwrap()),
));
let actual = Lint::SubjectNotSeparateFromBody.lint(&CommitMessage::from(message));
assert_eq!(
    actual, expected,
    "Expected {:?}, found {:?}",
    expected, actual
);

SubjectLongerThan72Characters

Check for a long subject line

Examples

Passing

use mit_commit::CommitMessage;
use mit_lint::Lint;

let message: &str = "An example commit

Some Body Content
"
.into();
let actual = Lint::SubjectLongerThan72Characters.lint(&CommitMessage::from(message));
assert!(actual.is_none(), "Expected None, found {:?}", actual);

Erring

use mit_commit::CommitMessage;
use mit_lint::{Code, Lint, Problem};

let message:String = "x".repeat(73).into();
let expected = Some(Problem::new(
      "Your subject is longer than 72 characters".into(),
    "It's important to keep the subject of the commit less than 72 characters because when you look at the git log, that's where it truncates the message. This means that people won't get the entirety of the information in your commit.\n\nPlease keep the subject line 72 characters or under"
        .into(),
    Code::SubjectLongerThan72Characters,&message.clone().into(),
    Some(vec![("Too long".to_string(), 72, 1)]),
    Some("https://git-scm.com/book/en/v2/Distributed-Git-Contributing-to-a-Project#_commit_guidelines".parse().unwrap()),
));
let actual = Lint::SubjectLongerThan72Characters.lint(&CommitMessage::from(message));
assert_eq!(
    actual, expected,
    "Expected {:?}, found {:?}",
    expected, actual
);

SubjectNotCapitalized

Check for a non-capitalised subject

Examples

Passing

use mit_commit::CommitMessage;
use mit_lint::Lint;

let message: &str = "An example commit\n".into();
let actual = Lint::SubjectNotCapitalized.lint(&CommitMessage::from(message));
assert!(actual.is_none(), "Expected None, found {:?}", actual);

Erring

use mit_commit::CommitMessage;
use mit_lint::{Code, Lint, Problem};

let message: &str =
    "an example commit\n"
.into();
let expected = Some(
    Problem::new(
        "Your commit message is missing a capital letter".into(),
        "The subject line is a title, and as such should be capitalised.\n\nYou can fix this by capitalising the first character in the subject".into(),
    Code::SubjectNotCapitalized,&message.into(),
    Some(vec![("Not capitalised".to_string(), 0, 1)]),
    Some("https://git-scm.com/book/en/v2/Distributed-Git-Contributing-to-a-Project#_commit_guidelines".parse().unwrap()),
)
);
let actual = Lint::SubjectNotCapitalized.lint(&CommitMessage::from(message));
assert_eq!(
    actual, expected,
    "Expected {:?}, found {:?}",
    expected, actual
);

SubjectEndsWithPeriod

Check for period at the end of the subject

Examples

Passing

use mit_commit::CommitMessage;
use mit_lint::Lint;

let message: &str = "An example commit\n".into();
let actual = Lint::SubjectEndsWithPeriod.lint(&CommitMessage::from(message));
assert!(actual.is_none(), "Expected None, found {:?}", actual);

Erring

use mit_commit::CommitMessage;
use mit_lint::{Code, Lint, Problem};

let message: &str =
    "An example commit.\n".into();
let expected = Some(
Problem::new(
    "Your commit message ends with a period".into(),
    "It's important to keep your commits short, because we only have a limited number of characters to use (72) before the subject line is truncated. Full stops aren't normally in subject lines, and take up an extra character, so we shouldn't use them in commit message subjects.\n\nYou can fix this by removing the period"
        .into(),
    Code::SubjectEndsWithPeriod,&message.into(),
    Some(vec![("Unneeded period".to_string(), 17, 1)]),
    Some("https://git-scm.com/book/en/v2/Distributed-Git-Contributing-to-a-Project#_commit_guidelines".parse().unwrap()),
)
);
let actual = Lint::SubjectEndsWithPeriod.lint(&CommitMessage::from(message));
assert_eq!(
    actual, expected,
    "Expected {:?}, found {:?}",
    expected, actual
);

BodyWiderThan72Characters

Check for a long body line

Examples

Passing

use mit_commit::CommitMessage;
use mit_lint::Lint;

let message: &str = "An example commit\n\nSome Body Content\n".into();
let actual = Lint::BodyWiderThan72Characters.lint(&CommitMessage::from(message));
assert!(actual.is_none(), "Expected None, found {:?}", actual);

Erring

use mit_commit::CommitMessage;
use mit_lint::{Code, Lint, Problem};

let message:String = ["Subject".to_string(), "x".repeat(73).into()].join("\n\n");
let expected = Some(Problem::new(
  "Your commit has a body wider than 72 characters".into(),
    "It's important to keep the body of the commit narrower than 72 characters because when you look at the git log, that's where it truncates the message. This means that people won't get the entirety of the information in your commit.\n\nYou can fix this by making the lines in your body no more than 72 characters"
        .into(),
    Code::BodyWiderThan72Characters,&message.clone().into(),
    Some(vec![("Too long".parse().unwrap(), 81, 1)]),
Some("https://git-scm.com/book/en/v2/Distributed-Git-Contributing-to-a-Project#_commit_guidelines".parse().unwrap())
));
let actual = Lint::BodyWiderThan72Characters.lint(&CommitMessage::from(message));
assert_eq!(
    actual, expected,
    "Expected {:?}, found {:?}",
    expected, actual
);

NotConventionalCommit

Check for commits following the conventional standard

Examples

Passing

use mit_commit::CommitMessage;
use mit_lint::Lint;

let message: &str = "refactor: An example commit\n\nSome Body Content\n".into();
let actual = Lint::NotConventionalCommit.lint(&CommitMessage::from(message));
assert!(actual.is_none(), "Expected None, found {:?}", actual);

Erring

use mit_commit::CommitMessage;
use mit_lint::{Code, Lint, Problem};

let message: &str =
    "An example commit\n\nSome Body Content\n"
.into();
let expected = Some(Problem::new(
      "Your commit message isn't in conventional style".into(),
     "It's important to follow the conventional commit style when creating your commit message. By using this style we can automatically calculate the version of software using deployment pipelines, and also generate changelogs and other useful information without human interaction.\n\nYou can fix it by following style\n\n<type>[optional scope]: <description>\n\n[optional body]\n\n[optional footer(s)]"
        .into(),
    Code::NotConventionalCommit,&message.into(),Some(vec![("Not conventional".to_string(), 0, 17)]),Some("https://www.conventionalcommits.org/".to_string()),
));
let actual = Lint::NotConventionalCommit.lint(&CommitMessage::from(message));
assert_eq!(
    actual, expected,
    "Expected {:?}, found {:?}",
    expected, actual
);

NotEmojiLog

Check for commits following the emoji log standard

Examples

Passing

use mit_commit::CommitMessage;
use mit_lint::Lint;

let message: &str = "📖 DOC: An example commit\n\nSome Body Content\n".into();
let actual = Lint::NotEmojiLog.lint(&CommitMessage::from(message));
assert!(actual.is_none(), "Expected None, found {:?}", actual);

Erring

use mit_commit::CommitMessage;
use mit_lint::{Code, Lint, Problem};

let message: &str =
    "An example commit\n\nSome Body Content\n"
.into();
let expected = Some(
Problem::new(
       "Your commit message isn't in emoji log style".into(),
     "It's important to follow the emoji log style when creating your commit message. By using this style we can automatically generate changelogs.\n\nYou can fix it using one of the prefixes:\n\n\n📦 NEW:\n👌 IMPROVE:\n🐛 FIX:\n📖 DOC:\n🚀 RELEASE:\n🤖 TEST:\n‼\u{fe0f} BREAKING:"
        .into(),
    Code::NotEmojiLog,&message.into(),Some(vec![("Not emoji log".to_string(), 0, 17)]),Some("https://github.com/ahmadawais/Emoji-Log".to_string()),
));
let actual = Lint::NotEmojiLog.lint(&CommitMessage::from(message));
assert_eq!(
    actual, expected,
    "Expected {:?}, found {:?}",
    expected, actual
);

Implementations

impl Lint

pub const fn name(self) -> &'static str

Get an lint’s unique name

impl Lint

pub fn all_lints() -> impl Iterator<Item = Self>

Iterator over all the lints

Examples

use mit_lint::Lint;
assert!(Lint::all_lints().next().is_some())

pub fn iterator() -> impl Iterator<Item = Self>

👎Deprecated since 0.1.5: iterator was an unusual name. Use all_lints

Iterator over all the lints

Examples

use mit_lint::Lint;
assert!(Lint::iterator().next().is_some())

pub fn enabled_by_default(self) -> bool

Check if a lint is enabled by default

Examples

use mit_lint::Lint;
assert!(Lint::SubjectNotSeparateFromBody.enabled_by_default());
assert!(!Lint::NotConventionalCommit.enabled_by_default());

pub fn config_key(self) -> String

Get a key suitable for a configuration document

Examples

use mit_lint::Lint;
assert_eq!(
    Lint::SubjectNotSeparateFromBody.config_key(),
    "mit.lint.subject-not-separated-from-body"
);

pub fn lint(self, commit_message: &CommitMessage<'_>) -> Option<Problem>

Run this lint on a commit message

Examples

use mit_commit::CommitMessage;
use mit_lint::Lint;
let actual =
    Lint::NotConventionalCommit.lint(&CommitMessage::from("An example commit message"));
assert!(actual.is_some());

pub fn from_names(names: Vec<&str>) -> Result<Vec<Self>, Error>

Try and convert a list of names into lints

Examples

use mit_lint::Lint;
let actual = Lint::from_names(vec!["not-emoji-log", "body-wider-than-72-characters"]);
assert_eq!(
    actual.unwrap(),
    vec![Lint::BodyWiderThan72Characters, Lint::NotEmojiLog]
);

Errors

If the lint does not exist

Trait Implementations

impl Arbitrary for Lint

fn arbitrary(g: &mut Gen) -> Self

Return an arbitrary value.

fn shrink(&self) -> Box<dyn Iterator<Item = Self>>

Return an iterator of values that are smaller than itself.

impl Clone for Lint

fn clone(&self) -> Lint

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Lint

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

Formats the value using the given formatter.

impl Display for Lint

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

Formats the value using the given formatter.

impl From<Lint> for &str

fn from(lint: Lint) -> Self

Get an lint’s unique name

Examples

use mit_lint::Lint;
let actual: &str = Lint::NotConventionalCommit.into();
assert_eq!(actual, Lint::NotConventionalCommit.name());

impl From<Lint> for String

fn from(from: Lint) -> Self

Converts to this type from the input type.

impl FromStr for Lint

type Err = Error

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl Hash for Lint

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

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 IntoEnumIterator for Lint

type Iterator = LintIter

fn iter() -> LintIter

impl Ord for Lint

fn cmp(&self, other: &Lint) -> 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 Lint

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

fn partial_cmp(&self, other: &Lint) -> 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 TryFrom<&str> for Lint

type Error = Error

The type returned in the event of a conversion error.

fn try_from(from: &str) -> Result<Self, Self::Error>

Performs the conversion.

impl Copy for Lint

impl Eq for Lint

impl StructuralPartialEq for Lint