/// Max width of the message body; not used for the subject line.

width: usize,

/// The string that identifies a comment when started in column 0 of a line.

comment_string: String,

pub fn new(width: usize, comment_string: &str) -> CommitMsgFmt {

CommitMsgFmt {

width,

comment_string: comment_string.into(),

}

}

pub fn filter(&self, input: &str) -> String {

let msg = parse(input, &self.comment_string);

// The output size can be less than the input size only if the input contains characters

// that will be trimmed, such as leading whitespace, which is improbable. It is more likely

// the output size will exceed the input size due to injected linefeeds and continuation

// indentation. There is no worthwhile way to dynamically estimate the size difference

// between input and output so we pad by a small constant factor big enough to fit the

// linefeeds of a 3rd quartile message of 14 lines, as if such a message were written in a

// single line.

let probable_capacity_required = input.len() + 20;

let mut buf = String::with_capacity(probable_capacity_required);

self.reflow_into(&mut buf, &msg);

buf

}

fn reflow_into(&self, buf: &mut String, msg: &[Token]) {

for tok in msg {

match *tok {

BlockQuote(s) | Comment(s) | FencedCodeBlock(s) | Literal(s) | Scissored(s)

| Trailer(s) => {

buf.push_str(s);

}

ListItem(ref indent, ref li, ref s) => {

let indent = &indent.0;

let li = &li.0;

let mut continuation = String::with_capacity(indent.len() + li.len());

continuation.push_str(indent);

continuation.push_str(&" ".repeat(li.len()));

buf.push_str(indent);

buf.push_str(li);

self.wrap_paragraph_into(buf, s, Some(&continuation));

}

Paragraph(ref p) => {

self.wrap_paragraph_into(buf, p, None);

}

Footnote(key, ref rest) => {

buf.push_str(key);

buf.push(' ');

let continuation = " ".repeat(key.graphemes(true).count() + 1);

self.wrap_paragraph_into(buf, rest.trim(), Some(&continuation));

}

Subject(s) => {

buf.push_str(s);

}

VerticalSpace => {}

}

buf.push('\n');

}

}

fn wrap_paragraph_into(&self, buf: &mut String, paragraph: &str, continuation: Option<&str>) {

let limit = match continuation {

Some(c) => self.width.saturating_sub(c.len()),

None => self.width,

};

let mut cur_line_len = 0;

for word in WordIter::new(paragraph, &self.comment_string) {

let word_len = word.graphemes(true).count();

// Not a new line so we need to fiddle with whitespace.

if cur_line_len != 0 {

if cur_line_len + word_len > limit {

cur_line_len = 0;

buf.push('\n');

if let Some(cont) = continuation {

buf.push_str(cont);

}

} else {

buf.push(' ');

}

}

buf.push_str(&word);

cur_line_len += word_len + 1;

}

}

use super::*;

use pretty_assertions::assert_eq;

fn filter(w: usize, s: &str) -> String {

CommitMsgFmt::new(w, "#").filter(s)

}

#[test]

fn formats_empty_string() {

assert_eq!("", filter(10, ""));

}

#[test]

fn formats_non_empty_string() {

assert_eq!(filter(10, "foo"), "foo\n");

}

#[test]

fn formats_long_single_line_message() {

let s = "f".repeat(100);

assert_eq!(filter(10, &s), "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff

}

#[test]

fn preserves_autosquash_subject_line() {

let original_subject = "f".repeat(100);

let autosquash_subject = format!("fixup! {}", original_subject);

let input = format!(

"

subject = autosquash_subject

);

let expected = format!(

"

subject = autosquash_subject

);

assert_eq!(filter(72, &input), expected);

}

#[test]

fn counts_line_length_by_graphemes() {

let s = "

assert_eq!(

filter(5, s),

"

"break before every changing grapheme"

);

}

#[test]

fn formats_trailers() {

let msg = "

assert_eq!(filter(10, msg), msg, "print trailers literally");

}

#[test]

fn formats_literals() {

let input = "

let expected = "

assert_eq!(filter(72, input), expected);

}

#[test]

fn preserves_fenced_code_block() {

let input = "

let expected = "

assert_eq!(filter(72, input), expected);

}

#[test]

fn preserves_fenced_code_block_interrupting_paragraph() {

let input = "

let expected = "

assert_eq!(filter(72, input), expected);

}

#[test]

fn ignores_fenced_code_block_with_tilde() {

let input = "

let expected = "

assert_eq!(filter(72, input), expected);

}

#[test]

fn preserves_block_quote() {

let input = "

let expected = input;

assert_eq!(filter(72, input), expected);

}

#[test]

fn preserves_block_quote_with_attribution() {

let input = "

let expected = input;

assert_eq!(filter(72, input), expected);

}

#[test]

fn preserves_multiline_block_quote() {

let input = "

let expected = "

assert_eq!(filter(30, input), expected);

}

#[test]

fn formats_footnotes() {

let msg = "

let expected = "

assert_eq!(filter(20, msg), expected);

}

#[test]

fn formats_footnote_references() {

let msg = "

let expected = "

assert_eq!(filter(8, msg), expected);

}

#[test]

fn wraps_long_list_items_aligning_continuation_line_with_content_start() {

let input = "

let expected = "

assert_eq!(filter(16, input), expected);

}

#[test]

fn realigns_misaligned_continuation_line() {

let input = "

let expected = "

assert_eq!(filter(34, input), expected);

}

#[test]

fn tolerates_continuation_longer_than_body_width() {

// If a continuation is longer than the requested body width it is

// impossible to wrap a footnote to within said width. Instead just

// break up the footnote as aggressively as possible.

let input = "

let expected = "

assert_eq!(filter(3, input), expected);

}

#[test]

fn joins_unnecessarily_wrapped_list_items() {

let input = "

let expected = "

assert_eq!(filter(72, input), expected);

}

#[test]

fn preserves_multiple_list_items() {

let input = "

let expected = "

assert_eq!(filter(72, input), expected);

}

#[test]

fn recognizes_list_item_indented_one_space() {

let input = "

let expected = "

assert_eq!(filter(72, input), expected);

}

#[test]

fn recognizes_different_list_types() {

let msg = "

assert_eq!(filter(72, msg), msg);

}

#[test]

fn preserves_scissored_content() {

let input = "

let expected = "

assert_eq!(filter(72, input), expected);

}

#[test]

fn preserves_comment() {

let input = "

let expected = "

assert_eq!(filter(2, input), expected);

}

#[test]

fn preserves_scissored_content_with_custom_comment_string() {

let input = "

let expected = "

let fmt = CommitMsgFmt::new(72, ";");

assert_eq!(fmt.filter(input), expected);

}

#[test]

fn bug_wrapping_treats_exotic_whitespace_differently_from_ascii_spaces() {

// Whether wrapping should treat all whitespace the same is debatable but certainly we only

// consider the regular ASCII space. This test documents the acknowledgement thereof, not a

// deliberate decision, and classifies it a bug for that reason.

//

// Some largely arbitrary whitespace characters from

// https://en.wikipedia.org/w/index.php?title=Whitespace_character&oldid=858017200

let input = "

let expected = "

assert_eq!(filter(2, input), expected);

}

#[test]

fn does_not_break_words() {

let input = "

let expected = "

assert_eq!(filter(10, input), expected);

}

#[test]

fn does_not_break_non_breaking_words() {

let input = "

let expected = "

assert_eq!(filter(2, input), expected);

}