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
102
103
104
105
106
107
108
109
110

use crate::{
	args::Args,
	authors::author::{Author, AuthorsProvider},
	git::{commit_mode::CommitMode, di::Service},
	ui::cli::Cli,
	Result,
};

pub struct Orchestrator {
	args: Args,
	cli: Cli,
	service: Service,
	provider: Box<dyn AuthorsProvider>,
}

impl Orchestrator {
	pub fn exec(args: Args, cli: Cli, service: Service, provider: Box<dyn AuthorsProvider>) -> Result<()> {
		let mut orch = Self {
			args,
			cli,
			service,
			provider,
		};
		let authors_signatures = orch.get_authors()?;
		orch.commit(authors_signatures)
	}

	fn get_authors(&mut self) -> Result<Vec<String>> {
		let all_authors = self.provider.all();
		if self.args.all {
			let all_signatures: Vec<_> = all_authors.iter().map(Author::signature).collect();
			return if self.args.sort {
				Ok(Self::sort(all_signatures))
			} else {
				Ok(all_signatures)
			};
		}

		if self.args.fzf {
			let found_authors: Vec<_> = self
				.provider
				.find_by_hashes(&self.cli.fzf_prompt(&all_authors)?)
				.iter()
				.map(Author::signature)
				.collect();
			return if self.args.sort {
				Ok(Self::sort(found_authors))
			} else {
				Ok(found_authors)
			};
		}

		let aliases = match &self.args.list {
			Some(list) => list.split(',').map(ToString::to_string).collect::<Vec<String>>(),
			None => self.cli.aliases_prompt(&all_authors)?,
		};
		let found_authors: Vec<_> = self
			.provider
			.find_by_aliases(&aliases)
			.iter()
			.map(Author::signature)
			.collect();

		if self.args.sort {
			Ok(Self::sort(found_authors))
		} else {
			Ok(found_authors)
		}
	}

	fn commit(&mut self, authors_signatures: Vec<String>) -> Result<()> {
		if self.args.amend {
			self.args.pre_populate = true;
		}

		if self.args.editor {
			if self.args.pre_populate {
				return self.service.commit(CommitMode::WithEditor {
					message: Some(self.service.last_commit_message().as_str()),
					authors: authors_signatures,
					amend: self.args.amend,
				});
			}
			return self.service.commit(CommitMode::WithEditor {
				message: None,
				authors: authors_signatures,
				amend: self.args.amend,
			});
		}

		let msg = match (self.args.message.clone(), self.args.pre_populate) {
			(Some(msg), _) => msg,
			(None, false) => self.cli.message_prompt()?,
			(None, true) => self
				.cli
				.pre_populated_message_prompt(&self.service.last_commit_message())?,
		};

		self.service.commit(CommitMode::WithoutEditor {
			message: msg.as_str(),
			authors: authors_signatures,
			amend: self.args.amend,
		})
	}

	fn sort<String: Ord>(mut vector: Vec<String>) -> Vec<String> {
		vector.sort();
		vector
	}
}