Struct Body

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

A single contiguous block of [CommitMessage] text

Implementations

impl<'a> Body<'a>

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

Append one Body onto another

This is for concatenating multiple [Bodies] together

Example

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

Is this Body empty

An empty Body usually indicate a paragraph break in a [CommitMessage] so it’s handy to be able to see them.

Example

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

assert_eq!(Body::from("").is_empty(), true)

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<'a> Display for Body<'a>

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

Formats the value using the given formatter.

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

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

Converts to this type from the input type.

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

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

Convert to a Cow<_, str>

Example

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

Converts to this type from the input type.

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

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

Converts to this type from the input type.

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 from a Cow<_, str>

Example

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<'a> From<String> for Body<'a>

fn from(body: String) -> Self

Converts to this type from the input type.

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>