Struct Body

pub struct Body<'a> { /* private fields */ }

A single contiguous block of [CommitMessage] text

Implementations

impl Body<'_>

pub fn append(&self, additional: &Self) -> Self

Append one Body onto another

Arguments

• additional - The body to append to this one

Returns

A new body with the content of both bodies separated by a newline

Examples

use indoc::indoc;
use mit_commit::Body;

assert_eq!(
    Body::from(indoc!(
        "
        Example 1
        Example 2"
    )),
    Body::from("Example 1").append(&Body::from("Example 2"))
)

pub fn is_empty(&self) -> bool

Checks if this Body is empty

Returns

true if the body is empty, false otherwise

Examples

use mit_commit::Body;

assert_eq!(Body::from("").is_empty(), true);
assert_eq!(Body::from("not empty").is_empty(), false);

Trait Implementations

impl<'a> Clone for Body<'a>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for Body<'a>

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

Formats the value using the given formatter.

impl<'a> Default for Body<'a>

fn default() -> Body<'a>

Returns the “default value” for a type.

impl Display for Body<'_>

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

Format the Body for display

Arguments

• f - The formatter to write to

Returns

A Result indicating whether the operation succeeded

impl<'a> From<&'a str> for Body<'a>

fn from(body: &'a str) -> Self

Create a Body from a string slice

Arguments

• body - The string slice to create the body from

Returns

A new Body containing the provided string

impl From<Body<'_>> for String

fn from(body: Body<'_>) -> Self

Convert a Body to a String

Arguments

• body - The body to convert

Returns

A String containing the body’s text

impl<'a> From<Body<'a>> for Cow<'a, str>

fn from(body: Body<'a>) -> Self

Convert a Body to a Cow<_, str>

Arguments

• body - The body to convert

Returns

A Cow<_, str> containing the body’s text

Examples

use std::borrow::Cow;

use mit_commit::Body;

let expected = Cow::from("a string");
let input = Body::from(expected.clone());
assert_eq!(Cow::from(input), expected)

impl<'a> From<Body<'a>> for Fragment<'a>

fn from(body: Body<'a>) -> Self

Create a Fragment from a Body

Arguments

• body - The body to convert into a fragment

Returns

A new Fragment::Body variant containing the provided body

Examples

use mit_commit::{Body, Fragment};

let body = Body::from("Example body");
let fragment = Fragment::from(body.clone());
assert_eq!(fragment, Fragment::Body(body));

impl<'a> From<Body<'a>> for Subject<'a>

fn from(body: Body<'_>) -> Self

Converts to this type from the input type.

impl<'a> From<Cow<'a, str>> for Body<'a>

fn from(body: Cow<'a, str>) -> Self

Create a Body from a Cow<_, str>

Arguments

• body - The string content to create the body from

Returns

A new Body containing the provided string

Examples

use std::borrow::Cow;

use mit_commit::Body;

let expected = "a string";
let input = Cow::from(expected);
assert_eq!(Body::from(input).to_string(), expected)

impl From<String> for Body<'_>

fn from(body: String) -> Self

Create a Body from a String

Arguments

• body - The string to create the body from

Returns

A new Body containing the provided string

impl<'a> PartialEq for Body<'a>

fn eq(&self, other: &Body<'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> TryFrom<Body<'a>> for Trailer<'a>

type Error = Error

The type returned in the event of a conversion error.

fn try_from(body: Body<'a>) -> Result<Self, Self::Error>

Performs the conversion.

impl<'a> Eq for Body<'a>

impl<'a> StructuralPartialEq for Body<'a>