Enum mit_lint::Lint[−][src]

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

The lints that are supported

Variants

DuplicatedTrailers

Check for duplicated trailers

Examples

Passing

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

let message: &str = indoc!(
    "
    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 indoc::indoc;
use mit_commit::CommitMessage;
use mit_lint::{Code, Lint, Problem};

let message: &str = indoc!(
    "
    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,
));
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 indoc::indoc;
use mit_commit::CommitMessage;
use mit_lint::Lint;

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

Erring

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

let message: &str = indoc!(
    "
    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,
));
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 indoc::indoc;
use mit_commit::CommitMessage;
use mit_lint::Lint;

let message: &str = indoc!(
    "
    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 indoc::indoc;
use mit_commit::CommitMessage;
use mit_lint::{Code, Lint, Problem};

let message: &str = indoc!(
    "
    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,
));
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 indoc::indoc;
use mit_commit::CommitMessage;
use mit_lint::Lint;

let message: &str = indoc!(
    "
    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 indoc::indoc;
use mit_commit::CommitMessage;
use mit_lint::{Code, Lint, Problem};

let message: &str = indoc!(
    "
    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,
));
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 indoc::indoc;
use mit_commit::CommitMessage;
use mit_lint::Lint;

let message: &str = indoc!(
    "
    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 indoc::indoc;
use mit_commit::CommitMessage;
use mit_lint::{Code, Lint, Problem};

let message: &str = indoc!(
    "
    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,
));
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 indoc::indoc;
use mit_commit::CommitMessage;
use mit_lint::Lint;

let message: &str = indoc!(
    "
    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 indoc::indoc;
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,
));
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 indoc::indoc;
use mit_commit::CommitMessage;
use mit_lint::Lint;

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

Erring

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

let message: &str = indoc!(
    "
    an example commit
    "
)
.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,
));
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 indoc::indoc;
use mit_commit::CommitMessage;
use mit_lint::Lint;

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

Erring

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

let message: &str = indoc!(
    "
    An example commit.
    "
)
.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,
));
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 indoc::indoc;
use mit_commit::CommitMessage;
use mit_lint::Lint;

let message: &str = indoc!(
    "
    An example commit

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

Erring

use indoc::indoc;
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,
));
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 indoc::indoc;
use mit_commit::CommitMessage;
use mit_lint::Lint;

let message: &str = indoc!(
    "
    refactor: An example commit

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

Erring

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

let message: &str = indoc!(
    "
    An example commit

    Some Body Content
    "
)
.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)]\n\nYou can read more at https://www.conventionalcommits.org/"
        .into(),
    Code::NotConventionalCommit,
));
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 indoc::indoc;
use mit_commit::CommitMessage;
use mit_lint::Lint;

let message: &str = indoc!(
    "
    📖 DOC: An example commit

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

Erring

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

let message: &str = indoc!(
    "
    An example commit

    Some Body Content
    "
)
.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📦 NEW:\n👌 IMPROVE:\n🐛 FIX:\n📖 DOC:\n🚀 RELEASE:🤖 TEST:\n‼\u{fe0f} BREAKING:\n\nYou can read more at https://github.com/ahmadawais/Emoji-Log"
        .into(),
    Code::NotEmojiLog,
));
let actual = Lint::NotEmojiLog.lint(&CommitMessage::from(message));
assert_eq!(
    actual, expected,
    "Expected {:?}, found {:?}",
    expected, actual
);

Implementations

Get an lint’s unique name

Iterator over all the lints

Examples

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

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());

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"
);

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());

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

Returns a copy of the value. Read more

Performs copy-assignment from source. Read more

Formats the value using the given formatter. Read more

Formats the value using the given formatter. Read more

Performs the conversion.

Performs the conversion.

Feeds this value into the given Hasher. Read more

Feeds a slice of this type into the given Hasher. Read more

This method returns an Ordering between self and other. Read more

Compares and returns the maximum of two values. Read more

Compares and returns the minimum of two values. Read more

Restrict a value to a certain interval. Read more

This method tests for self and other values to be equal, and is used by ==. Read more

This method tests for !=.

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

This method tests less than (for self and other) and is used by the < operator. Read more

This method tests less than or equal to (for self and other) and is used by the <= operator. Read more

This method tests greater than (for self and other) and is used by the > operator. Read more

This method tests greater than or equal to (for self and other) and is used by the >= operator. Read more

The type returned in the event of a conversion error.

Performs the conversion.

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

Immutably borrows from an owned value. Read more

Mutably borrows from an owned value. Read more

Performs the conversion.

Performs the conversion.

The resulting type after obtaining ownership.

Creates owned data from borrowed data, usually by cloning. Read more

🔬 This is a nightly-only experimental API. (toowned_clone_into)

recently added

Uses borrowed data to replace owned data, usually by cloning. Read more

Converts the given value to a String. Read more

The type returned in the event of a conversion error.

Performs the conversion.

The type returned in the event of a conversion error.

Performs the conversion.