co-author 0.1.3

Co-Author your git commits from the command line
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101

use super::{cli::Cli, input_reader::MockInputReader};
use crate::{authors::author::Author, common::runner::MockRunner};

#[test]
fn prompt_for_message() {
	let mut reader = MockInputReader::new();
	reader
		.expect_readline()
		.withf(|prompt_msg| prompt_msg.contains("Enter commit message"))
		.times(1)
		.returning(|_| Ok("whatever".to_string()));
	let mut cli = Cli::new(Box::new(reader), Box::new(MockRunner::new()));

	let _ = cli.message_prompt();
	// Only interested in params passed to the mock (withf)
}

#[test]
fn trim_message() {
	let trimmed_msg = "test commit message";
	let padded_msg = format!(" {trimmed_msg}  ");
	let mut reader = MockInputReader::new();
	reader
		.expect_readline()
		.times(1)
		.returning(move |_| Ok(padded_msg.clone()));
	let mut cli = Cli::new(Box::new(reader), Box::new(MockRunner::new()));

	let result = cli.message_prompt();

	assert!(matches!(result, Ok(msg) if msg == trimmed_msg));
}

#[test]
fn prompt_for_aliases() {
	let mut reader = MockInputReader::new();
	reader
		.expect_readline()
		.withf(|prompt_msg| prompt_msg.contains("Enter co-authors aliases"))
		.times(1)
		.returning(|_| Ok("whatever".to_string()));
	let mut cli = Cli::new(Box::new(reader), Box::new(MockRunner::new()));

	let _ = cli.aliases_prompt(&[]);
	// Only interested in params passed to the mock (withf)
}

#[test]
fn space_split_aliases() {
	let aliases = " a b cd   ";
	let mut reader = MockInputReader::new();
	reader
		.expect_readline()
		.times(1)
		.returning(move |_| Ok(aliases.to_string()));
	let mut cli = Cli::new(Box::new(reader), Box::new(MockRunner::new()));

	let result = cli.aliases_prompt(&[]);

	assert!(matches!(result, Ok(aliases) if aliases == ["a", "b", "cd"]));
}

#[test]
fn pretty_print_authors_when_prompting_for_aliases() {
	let alias = "a";
	let name = "alice";
	let author = Author::from(alias, name, "email");
	let mut reader = MockInputReader::new();
	reader
		.expect_readline()
		.withf(move |prompt_msg| contains_in_order(prompt_msg, &["⦔", alias, "->", name]))
		.times(1)
		.returning(move |_| Ok("whatever".to_string()));
	let mut cli = Cli::new(Box::new(reader), Box::new(MockRunner::new()));

	let _ = cli.aliases_prompt(&[author]);
	// Only interested in params passed to the mock (withf)
}

#[test]
fn prompt_for_aliases_using_fzf() {
	let mut runner = MockRunner::new();
	runner
		.expect_attach()
		.withf(|cmd, args| cmd == "fzf" && args == ["--multi".to_string(), "--ansi".to_string()])
		.times(1)
		.returning(|_, _| Err("irrelevant".into())); // This is done to avoid creating a Child
	let cli = Cli::new(Box::new(MockInputReader::new()), Box::new(runner));

	let _ = cli.fzf_prompt(&[]);
	// Only interested in params passed to the mock (withf)
}

fn contains_in_order(prompt_msg: &str, components: &[&str]) -> bool {
	// This is functionally equal to doing prompt_msg.contains("⦔ alias -> name")
	// but only considers presence and relative order, discarding "colored" formatting (bold, colors, etc.)
	let found: Vec<_> = components.iter().map(|comp| prompt_msg.find(comp)).collect();
	let are_contained = found.iter().all(|&comp| comp.is_some());
	let are_in_order = found.windows(2).all(|comp| comp[0] < comp[1]);
	are_contained && are_in_order
}