1extern crate ansi_term;
2extern crate chrono;
3#[macro_use]
4extern crate clap;
5extern crate colorparse;
6extern crate git2;
7extern crate isatty;
8#[macro_use]
9extern crate quick_error;
10extern crate tempdir;
11
12use std::env;
13use std::ffi::{OsStr, OsString};
14use std::fmt::Write as FmtWrite;
15use std::fs::File;
16use std::io::Read;
17use std::io::Write as IoWrite;
18use std::process::Command;
19use ansi_term::Style;
20use chrono::offset::TimeZone;
21use clap::{App, AppSettings, Arg, ArgGroup, ArgMatches, SubCommand};
22use git2::{Config, Commit, Diff, Object, ObjectType, Oid, Reference, Repository, TreeBuilder};
23use tempdir::TempDir;
24
25quick_error! {
26 #[derive(Debug)]
27 enum Error {
28 Git2(err: git2::Error) {
29 from()
30 cause(err)
31 display("{}", err)
32 }
33 IO(err: std::io::Error) {
34 from()
35 cause(err)
36 display("{}", err)
37 }
38 Msg(msg: String) {
39 from()
40 from(s: &'static str) -> (s.to_string())
41 description(msg)
42 display("{}", msg)
43 }
44 Utf8Error(err: std::str::Utf8Error) {
45 from()
46 cause(err)
47 display("{}", err)
48 }
49 }
50}
51
52type Result<T> = std::result::Result<T, Error>;
53
54const COMMIT_MESSAGE_COMMENT: &'static str = "
55# Please enter the commit message for your changes. Lines starting
56# with '#' will be ignored, and an empty message aborts the commit.
57";
58const COVER_LETTER_COMMENT: &'static str = "
59# Please enter the cover letter for your changes. Lines starting
60# with '#' will be ignored, and an empty message aborts the change.
61";
62const REBASE_COMMENT: &'static str = "\
63#
64# Commands:
65# p, pick = use commit
66# r, reword = use commit, but edit the commit message
67# e, edit = use commit, but stop for amending
68# s, squash = use commit, but meld into previous commit
69# f, fixup = like \"squash\", but discard this commit's log message
70# x, exec = run command (the rest of the line) using shell
71# d, drop = remove commit
72#
73# These lines can be re-ordered; they are executed from top to bottom.
74#
75# If you remove a line here THAT COMMIT WILL BE LOST.
76#
77# However, if you remove everything, the rebase will be aborted.
78";
79const SCISSOR_LINE: &'static str = "\
80# ------------------------ >8 ------------------------";
81const SCISSOR_COMMENT: &'static str = "\
82# Do not touch the line above.
83# Everything below will be removed.
84";
85
86const SHELL_METACHARS: &'static str = "|&;<>()$`\\\"' \t\n*?[#~=%";
87
88const SERIES_PREFIX: &'static str = "refs/heads/git-series/";
89const SHEAD_REF: &'static str = "refs/SHEAD";
90const STAGED_PREFIX: &'static str = "refs/git-series-internals/staged/";
91const WORKING_PREFIX: &'static str = "refs/git-series-internals/working/";
92
93const GIT_FILEMODE_BLOB: u32 = 0o100644;
94const GIT_FILEMODE_COMMIT: u32 = 0o160000;
95
96fn zero_oid() -> Oid {
97 Oid::from_bytes(b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00").unwrap()
98}
99
100fn peel_to_commit(r: Reference) -> Result<Commit> {
101 Ok(try!(try!(r.peel(ObjectType::Commit)).into_commit().map_err(|obj| format!("Internal error: expected a commit: {}", obj.id()))))
102}
103
104fn commit_obj_summarize_components(commit: &mut Commit) -> Result<(String, String)> {
105 let short_id_buf = try!(commit.as_object().short_id());
106 let short_id = short_id_buf.as_str().unwrap();
107 let summary = String::from_utf8_lossy(commit.summary_bytes().unwrap());
108 Ok((short_id.to_string(), summary.to_string()))
109}
110
111fn commit_summarize_components(repo: &Repository, id: Oid) -> Result<(String, String)> {
112 let mut commit = try!(repo.find_commit(id));
113 commit_obj_summarize_components(&mut commit)
114}
115
116fn commit_obj_summarize(commit: &mut Commit) -> Result<String> {
117 let (short_id, summary) = try!(commit_obj_summarize_components(commit));
118 Ok(format!("{} {}", short_id, summary))
119}
120
121fn commit_summarize(repo: &Repository, id: Oid) -> Result<String> {
122 let mut commit = try!(repo.find_commit(id));
123 commit_obj_summarize(&mut commit)
124}
125
126fn notfound_to_none<T>(result: std::result::Result<T, git2::Error>) -> Result<Option<T>> {
127 match result {
128 Err(ref e) if e.code() == git2::ErrorCode::NotFound => Ok(None),
129 Err(e) => Err(e.into()),
130 Ok(x) => Ok(Some(x)),
131 }
132}
133
134// If current_id_opt is Some, acts like reference_matching. If current_id_opt is None, acts like
135// reference.
136fn reference_matching_opt<'repo>(repo: &'repo Repository, name: &str, id: Oid, force: bool, current_id_opt: Option<Oid>, log_message: &str) -> Result<Reference<'repo>> {
137 match current_id_opt {
138 None => Ok(try!(repo.reference(name, id, force, log_message))),
139 Some(current_id) => Ok(try!(repo.reference_matching(name, id, force, current_id, log_message))),
140 }
141}
142
143fn parents_from_ids(repo: &Repository, mut parents: Vec<Oid>) -> Result<Vec<Commit>> {
144 parents.sort();
145 parents.dedup();
146 parents.drain(..).map(|id| Ok(try!(repo.find_commit(id)))).collect::<Result<Vec<Commit>>>()
147}
148
149struct Internals<'repo> {
150 staged: TreeBuilder<'repo>,
151 working: TreeBuilder<'repo>,
152}
153
154impl<'repo> Internals<'repo> {
155 fn read(repo: &'repo Repository) -> Result<Self> {
156 let shead = try!(repo.find_reference(SHEAD_REF));
157 let series_name = try!(shead_series_name(&shead));
158 let mut internals = try!(Internals::read_series(repo, &series_name));
159 try!(internals.update_series(repo));
160 Ok(internals)
161 }
162
163 fn read_series(repo: &'repo Repository, series_name: &str) -> Result<Self> {
164 let committed_id = try!(notfound_to_none(repo.refname_to_id(&format!("{}{}", SERIES_PREFIX, series_name))));
165 let maybe_get_ref = |prefix: &str| -> Result<TreeBuilder<'repo>> {
166 match try!(notfound_to_none(repo.refname_to_id(&format!("{}{}", prefix, series_name)))).or(committed_id) {
167 Some(id) => {
168 let c = try!(repo.find_commit(id));
169 let t = try!(c.tree());
170 Ok(try!(repo.treebuilder(Some(&t))))
171 }
172 None => Ok(try!(repo.treebuilder(None))),
173 }
174 };
175 Ok(Internals {
176 staged: try!(maybe_get_ref(STAGED_PREFIX)),
177 working: try!(maybe_get_ref(WORKING_PREFIX)),
178 })
179 }
180
181 fn exists(repo: &'repo Repository, series_name: &str) -> Result<bool> {
182 for prefix in [SERIES_PREFIX, STAGED_PREFIX, WORKING_PREFIX].iter() {
183 let prefixed_name = format!("{}{}", prefix, series_name);
184 if try!(notfound_to_none(repo.refname_to_id(&prefixed_name))).is_some() {
185 return Ok(true);
186 }
187 }
188 Ok(false)
189 }
190
191 // Returns true if it had anything to delete.
192 fn delete(repo: &'repo Repository, series_name: &str) -> Result<bool> {
193 let mut deleted_any = false;
194 for prefix in [STAGED_PREFIX, WORKING_PREFIX].iter() {
195 let prefixed_name = format!("{}{}", prefix, series_name);
196 if let Some(mut r) = try!(notfound_to_none(repo.find_reference(&prefixed_name))) {
197 try!(r.delete());
198 deleted_any = true;
199 }
200 }
201 Ok(deleted_any)
202 }
203
204 fn update_series(&mut self, repo: &'repo Repository) -> Result<()> {
205 let head_id = try!(repo.refname_to_id("HEAD"));
206 try!(self.working.insert("series", head_id, GIT_FILEMODE_COMMIT as i32));
207 Ok(())
208 }
209
210 fn write(&self, repo: &'repo Repository) -> Result<()> {
211 let config = try!(repo.config());
212 let author = try!(get_signature(&config, "AUTHOR"));
213 let committer = try!(get_signature(&config, "COMMITTER"));
214
215 let shead = try!(repo.find_reference(SHEAD_REF));
216 let series_name = try!(shead_series_name(&shead));
217 let maybe_commit = |prefix: &str, tb: &TreeBuilder| -> Result<()> {
218 let tree_id = try!(tb.write());
219 let refname = format!("{}{}", prefix, series_name);
220 let old_commit_id = try!(notfound_to_none(repo.refname_to_id(&refname)));
221 if let Some(id) = old_commit_id {
222 let c = try!(repo.find_commit(id));
223 if c.tree_id() == tree_id {
224 return Ok(());
225 }
226 }
227 let tree = try!(repo.find_tree(tree_id));
228 let mut parents = Vec::new();
229 // Include all commits from tree, to keep them reachable and fetchable. Include base,
230 // because series might not have it as an ancestor; we don't enforce that until commit.
231 for e in tree.iter() {
232 if e.kind() == Some(ObjectType::Commit) {
233 parents.push(e.id());
234 }
235 }
236 let parents = try!(parents_from_ids(repo, parents));
237 let parents_ref: Vec<&_> = parents.iter().collect();
238 let commit_id = try!(repo.commit(None, &author, &committer, &refname, &tree, &parents_ref));
239 try!(repo.reference_ensure_log(&refname));
240 try!(reference_matching_opt(repo, &refname, commit_id, true, old_commit_id, &format!("commit: {}", refname)));
241 Ok(())
242 };
243 try!(maybe_commit(STAGED_PREFIX, &self.staged));
244 try!(maybe_commit(WORKING_PREFIX, &self.working));
245 Ok(())
246 }
247}
248
249fn diff_empty(diff: &Diff) -> bool {
250 diff.deltas().len() == 0
251}
252
253fn add(repo: &Repository, m: &ArgMatches) -> Result<()> {
254 let mut internals = try!(Internals::read(repo));
255 for file in m.values_of_os("change").unwrap() {
256 match try!(internals.working.get(file)) {
257 Some(entry) => { try!(internals.staged.insert(file, entry.id(), entry.filemode())); }
258 None => {
259 if try!(internals.staged.get(file)).is_some() {
260 try!(internals.staged.remove(file));
261 }
262 }
263 }
264 }
265 internals.write(repo)
266}
267
268fn unadd(repo: &Repository, m: &ArgMatches) -> Result<()> {
269 let shead = try!(repo.find_reference(SHEAD_REF));
270 let started = {
271 let shead_target = try!(shead.symbolic_target().ok_or("SHEAD not a symbolic reference"));
272 try!(notfound_to_none(repo.find_reference(shead_target))).is_some()
273 };
274
275 let mut internals = try!(Internals::read(repo));
276 if started {
277 let shead_commit = try!(peel_to_commit(shead));
278 let shead_tree = try!(shead_commit.tree());
279
280 for file in m.values_of("change").unwrap() {
281 match shead_tree.get_name(file) {
282 Some(entry) => {
283 try!(internals.staged.insert(file, entry.id(), entry.filemode()));
284 }
285 None => { try!(internals.staged.remove(file)); }
286 }
287 }
288 } else {
289 for file in m.values_of("change").unwrap() {
290 try!(internals.staged.remove(file))
291 }
292 }
293 internals.write(repo)
294}
295
296fn shead_series_name(shead: &Reference) -> Result<String> {
297 let shead_target = try!(shead.symbolic_target().ok_or("SHEAD not a symbolic reference"));
298 if !shead_target.starts_with(SERIES_PREFIX) {
299 return Err(format!("SHEAD does not start with {}", SERIES_PREFIX).into());
300 }
301 Ok(shead_target[SERIES_PREFIX.len()..].to_string())
302}
303
304fn series(out: &mut Output, repo: &Repository) -> Result<()> {
305 let mut refs = Vec::new();
306 for prefix in [SERIES_PREFIX, STAGED_PREFIX, WORKING_PREFIX].iter() {
307 let l = prefix.len();
308 for r in try!(repo.references_glob(&[prefix, "*"].concat())).names() {
309 refs.push(try!(r)[l..].to_string());
310 }
311 }
312 let shead_target = if let Some(shead) = try!(notfound_to_none(repo.find_reference(SHEAD_REF))) {
313 Some(try!(shead_series_name(&shead)).to_string())
314 } else {
315 None
316 };
317 refs.extend(shead_target.clone().into_iter());
318 refs.sort();
319 refs.dedup();
320
321 let config = try!(try!(repo.config()).snapshot());
322 try!(out.auto_pager(&config, "branch", false));
323 let color_current = try!(out.get_color(&config, "branch", "current", "green"));
324 let color_plain = try!(out.get_color(&config, "branch", "plain", "normal"));
325 for name in refs.iter() {
326 let (star, color) = if Some(name) == shead_target.as_ref() {
327 ('*', color_current)
328 } else {
329 (' ', color_plain)
330 };
331 let new = if try!(notfound_to_none(repo.refname_to_id(&format!("{}{}", SERIES_PREFIX, name)))).is_none() {
332 " (new, no commits yet)"
333 } else {
334 ""
335 };
336 try!(writeln!(out, "{} {}{}", star, color.paint(name as &str), new));
337 }
338 if refs.is_empty() {
339 try!(writeln!(out, "No series; use \"git series start <name>\" to start"));
340 }
341 Ok(())
342}
343
344fn start(repo: &Repository, m: &ArgMatches) -> Result<()> {
345 let name = m.value_of("name").unwrap();
346 if try!(Internals::exists(repo, name)) {
347 return Err(format!("Series {} already exists.\nUse checkout to resume working on an existing patch series.", name).into());
348 }
349 let prefixed_name = &[SERIES_PREFIX, name].concat();
350 try!(repo.reference_symbolic(SHEAD_REF, &prefixed_name, true, &format!("git series start {}", name)));
351
352 let internals = try!(Internals::read(repo));
353 try!(internals.write(repo));
354 Ok(())
355}
356
357fn checkout_tree(repo: &Repository, treeish: &Object) -> Result<()> {
358 let mut conflicts = Vec::new();
359 let mut dirty = Vec::new();
360 let result = {
361 let mut opts = git2::build::CheckoutBuilder::new();
362 opts.safe();
363 opts.notify_on(git2::CHECKOUT_NOTIFICATION_CONFLICT | git2::CHECKOUT_NOTIFICATION_DIRTY);
364 opts.notify(|t, path, _, _, _| {
365 let path = path.unwrap().to_owned();
366 if t == git2::CHECKOUT_NOTIFICATION_CONFLICT {
367 conflicts.push(path);
368 } else if t == git2::CHECKOUT_NOTIFICATION_DIRTY {
369 dirty.push(path);
370 }
371 true
372 });
373 if isatty::stdout_isatty() {
374 opts.progress(|_, completed, total| {
375 let total = total.to_string();
376 print!("\rChecking out files: {1:0$}/{2}", total.len(), completed, total);
377 });
378 }
379 repo.checkout_tree(treeish, Some(&mut opts))
380 };
381 match result {
382 Err(ref e) if e.code() == git2::ErrorCode::Conflict => {
383 let mut msg = String::new();
384 writeln!(msg, "error: Your changes to the following files would be overwritten by checkout:").unwrap();
385 for path in conflicts {
386 writeln!(msg, " {}", path.to_string_lossy()).unwrap();
387 }
388 writeln!(msg, "Please, commit your changes or stash them before you switch series.").unwrap();
389 return Err(msg.into());
390 }
391 _ => try!(result),
392 }
393 println!("");
394 if !dirty.is_empty() {
395 let mut stderr = std::io::stderr();
396 writeln!(stderr, "Files with changes unaffected by checkout:").unwrap();
397 for path in dirty {
398 writeln!(stderr, " {}", path.to_string_lossy()).unwrap();
399 }
400 }
401 Ok(())
402}
403
404fn checkout(repo: &Repository, m: &ArgMatches) -> Result<()> {
405 match repo.state() {
406 git2::RepositoryState::Clean => (),
407 s => { return Err(format!("{:?} in progress; cannot checkout patch series", s).into()); }
408 }
409 let name = m.value_of("name").unwrap();
410 if !try!(Internals::exists(repo, name)) {
411 return Err(format!("Series {} does not exist.\nUse \"git series start <name>\" to start a new patch series.", name).into());
412 }
413
414 let internals = try!(Internals::read_series(repo, name));
415 let new_head_id = try!(try!(internals.working.get("series")).ok_or(format!("Could not find \"series\" in \"{}\"", name))).id();
416 let new_head = try!(repo.find_commit(new_head_id)).into_object();
417
418 try!(checkout_tree(repo, &new_head));
419
420 let head = try!(repo.head());
421 let head_commit = try!(peel_to_commit(head));
422 let head_id = head_commit.as_object().id();
423 println!("Previous HEAD position was {}", try!(commit_summarize(&repo, head_id)));
424
425 let prefixed_name = &[SERIES_PREFIX, name].concat();
426 try!(repo.reference_symbolic(SHEAD_REF, &prefixed_name, true, &format!("git series checkout {}", name)));
427 try!(internals.write(repo));
428
429 // git status parses this reflog string; the prefix must remain "checkout: moving from ".
430 try!(repo.reference("HEAD", new_head_id, true, &format!("checkout: moving from {} to {} (git series checkout {})", head_id, new_head_id, name)));
431 println!("HEAD is now detached at {}", try!(commit_summarize(&repo, new_head_id)));
432
433 Ok(())
434}
435
436fn base(repo: &Repository, m: &ArgMatches) -> Result<()> {
437 let mut internals = try!(Internals::read(repo));
438
439 let current_base_id = match try!(internals.working.get("base")) {
440 Some(entry) => entry.id(),
441 _ => zero_oid(),
442 };
443
444 if !m.is_present("delete") && !m.is_present("base") {
445 if current_base_id.is_zero() {
446 return Err("Patch series has no base set".into());
447 } else {
448 println!("{}", current_base_id);
449 return Ok(());
450 }
451 }
452
453 let new_base_id = if m.is_present("delete") {
454 zero_oid()
455 } else {
456 let base = m.value_of("base").unwrap();
457 let base_object = try!(repo.revparse_single(base));
458 let base_id = base_object.id();
459 let s_working_series = try!(try!(internals.working.get("series")).ok_or("Could not find entry \"series\" in working vesion of current series"));
460 if base_id != s_working_series.id() && !try!(repo.graph_descendant_of(s_working_series.id(), base_id)) {
461 return Err(format!("Cannot set base to {}: not an ancestor of the patch series {}", base, s_working_series.id()).into());
462 }
463 base_id
464 };
465
466 if current_base_id == new_base_id {
467 return Err("Base unchanged".into());
468 }
469
470 if !current_base_id.is_zero() {
471 println!("Previous base was {}", try!(commit_summarize(&repo, current_base_id)));
472 }
473
474 if new_base_id.is_zero() {
475 try!(internals.working.remove("base"));
476 try!(internals.write(repo));
477 println!("Cleared patch series base");
478 } else {
479 try!(internals.working.insert("base", new_base_id, GIT_FILEMODE_COMMIT as i32));
480 try!(internals.write(repo));
481 println!("Set patch series base to {}", try!(commit_summarize(&repo, new_base_id)));
482 }
483
484 Ok(())
485}
486
487fn detach(repo: &Repository) -> Result<()> {
488 match repo.find_reference(SHEAD_REF) {
489 Ok(mut r) => try!(r.delete()),
490 Err(_) => { return Err("No current patch series to detach from.".into()); }
491 }
492 Ok(())
493}
494
495fn delete(repo: &Repository, m: &ArgMatches) -> Result<()> {
496 let name = m.value_of("name").unwrap();
497 if let Ok(shead) = repo.find_reference(SHEAD_REF) {
498 let shead_target = try!(shead_series_name(&shead));
499 if shead_target == name {
500 return Err(format!("Cannot delete the current series \"{}\"; detach first.", name).into());
501 }
502 }
503 let prefixed_name = &[SERIES_PREFIX, name].concat();
504 let deleted_ref = if let Some(mut r) = try!(notfound_to_none(repo.find_reference(prefixed_name))) {
505 try!(r.delete());
506 true
507 } else {
508 false
509 };
510 let deleted_internals = try!(Internals::delete(repo, name));
511 if !deleted_ref && !deleted_internals {
512 return Err(format!("Nothing to delete: series \"{}\" does not exist.", name).into());
513 }
514 Ok(())
515}
516
517fn get_editor(config: &Config) -> Result<OsString> {
518 if let Some(e) = env::var_os("GIT_EDITOR") {
519 return Ok(e);
520 }
521 if let Ok(e) = config.get_path("core.editor") {
522 return Ok(e.into());
523 }
524 let terminal_is_dumb = match env::var_os("TERM") {
525 None => true,
526 Some(t) => t.as_os_str() == "dumb",
527 };
528 if !terminal_is_dumb {
529 if let Some(e) = env::var_os("VISUAL") {
530 return Ok(e);
531 }
532 }
533 if let Some(e) = env::var_os("EDITOR") {
534 return Ok(e);
535 }
536 if terminal_is_dumb {
537 return Err("TERM unset or \"dumb\" but EDITOR unset".into());
538 }
539 return Ok("vi".into());
540}
541
542// Get the pager to use; with for_cmd set, get the pager for use by the
543// specified git command. If get_pager returns None, don't use a pager.
544fn get_pager(config: &Config, for_cmd: &str, default: bool) -> Option<OsString> {
545 if !isatty::stdout_isatty() {
546 return None;
547 }
548 // pager.cmd can contain a boolean (if false, force no pager) or a
549 // command-specific pager; only treat it as a command if it doesn't parse
550 // as a boolean.
551 let maybe_pager = config.get_path(&format!("pager.{}", for_cmd)).ok();
552 let (cmd_want_pager, cmd_pager) = maybe_pager.map_or((default, None), |p|
553 if let Ok(b) = Config::parse_bool(&p) {
554 (b, None)
555 } else {
556 (true, Some(p))
557 }
558 );
559 if !cmd_want_pager {
560 return None;
561 }
562 let pager =
563 if let Some(e) = env::var_os("GIT_PAGER") {
564 Some(e)
565 } else if let Some(p) = cmd_pager {
566 Some(p.into())
567 } else if let Ok(e) = config.get_path("core.pager") {
568 Some(e.into())
569 } else if let Some(e) = env::var_os("PAGER") {
570 Some(e)
571 } else {
572 Some("less".into())
573 };
574 pager.and_then(|p| if p.is_empty() || p == OsString::from("cat") { None } else { Some(p) })
575}
576
577/// Construct a Command, using the shell if the command contains shell metachars
578fn cmd_maybe_shell<S: AsRef<OsStr>>(program: S, args: bool) -> Command {
579 if program.as_ref().to_string_lossy().contains(|c| SHELL_METACHARS.contains(c)) {
580 let mut cmd = Command::new("sh");
581 cmd.arg("-c");
582 if args {
583 let mut program_with_args = program.as_ref().to_os_string();
584 program_with_args.push(" \"$@\"");
585 cmd.arg(program_with_args).arg(program);
586 } else {
587 cmd.arg(program);
588 }
589 cmd
590 } else {
591 Command::new(program)
592 }
593}
594
595fn run_editor<S: AsRef<OsStr>>(config: &Config, filename: S) -> Result<()> {
596 let editor = try!(get_editor(&config));
597 let editor_status = try!(cmd_maybe_shell(editor, true).arg(&filename).status());
598 if !editor_status.success() {
599 return Err(format!("Editor exited with status {}", editor_status).into());
600 }
601 Ok(())
602}
603
604struct Output {
605 pager: Option<std::process::Child>,
606 include_stderr: bool,
607}
608
609impl Output {
610 fn new() -> Self {
611 Output { pager: None, include_stderr: false }
612 }
613
614 fn auto_pager(&mut self, config: &Config, for_cmd: &str, default: bool) -> Result<()> {
615 if let Some(pager) = get_pager(config, for_cmd, default) {
616 let mut cmd = cmd_maybe_shell(pager, false);
617 cmd.stdin(std::process::Stdio::piped());
618 if env::var_os("LESS").is_none() {
619 cmd.env("LESS", "FRX");
620 }
621 if env::var_os("LV").is_none() {
622 cmd.env("LV", "-c");
623 }
624 let child = try!(cmd.spawn());
625 self.pager = Some(child);
626 self.include_stderr = isatty::stderr_isatty();
627 }
628 Ok(())
629 }
630
631 // Get a color to write text with, taking git configuration into account.
632 //
633 // config: the configuration to determine the color from.
634 // command: the git command to act like.
635 // slot: the color "slot" of that git command to act like.
636 // default: the color to use if not configured.
637 fn get_color(&self, config: &Config, command: &str, slot: &str, default: &str) -> Result<Style> {
638 if !cfg!(unix) {
639 return Ok(Style::new());
640 }
641 let color_ui = try!(notfound_to_none(config.get_str("color.ui"))).unwrap_or("auto");
642 let color_cmd = try!(notfound_to_none(config.get_str(&format!("color.{}", command)))).unwrap_or(color_ui);
643 if color_cmd == "never" || Config::parse_bool(color_cmd) == Ok(false) {
644 return Ok(Style::new());
645 }
646 if self.pager.is_some() {
647 let color_pager = try!(notfound_to_none(config.get_bool(&format!("color.pager")))).unwrap_or(true);
648 if !color_pager {
649 return Ok(Style::new());
650 }
651 } else if !isatty::stdout_isatty() {
652 return Ok(Style::new());
653 }
654 let cfg = format!("color.{}.{}", command, slot);
655 let color = try!(notfound_to_none(config.get_str(&cfg))).unwrap_or(default);
656 colorparse::parse(color).map_err(|e| format!("Error parsing {}: {}", cfg, e).into())
657 }
658
659 fn write_err(&mut self, msg: &str) {
660 if self.include_stderr {
661 if write!(self, "{}", msg).is_err() {
662 write!(std::io::stderr(), "{}", msg).unwrap();
663 }
664 } else {
665 write!(std::io::stderr(), "{}", msg).unwrap();
666 }
667 }
668}
669
670impl Drop for Output {
671 fn drop(&mut self) {
672 if let Some(ref mut child) = self.pager {
673 let status = child.wait().unwrap();
674 if !status.success() {
675 writeln!(std::io::stderr(), "Pager exited with status {}", status).unwrap();
676 }
677 }
678 }
679}
680
681impl IoWrite for Output {
682 fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
683 match self.pager {
684 Some(ref mut child) => child.stdin.as_mut().unwrap().write(buf),
685 None => std::io::stdout().write(buf),
686 }
687 }
688
689 fn flush(&mut self) -> std::io::Result<()> {
690 match self.pager {
691 Some(ref mut child) => child.stdin.as_mut().unwrap().flush(),
692 None => std::io::stdout().flush(),
693 }
694 }
695}
696
697fn get_signature(config: &Config, which: &str) -> Result<git2::Signature<'static>> {
698 let name_var = ["GIT_", which, "_NAME"].concat();
699 let email_var = ["GIT_", which, "_EMAIL"].concat();
700 let which_lc = which.to_lowercase();
701 let name = try!(env::var(&name_var).or_else(
702 |_| config.get_string("user.name").or_else(
703 |_| Err(format!("Could not determine {} name: checked ${} and user.name in git config", which_lc, name_var)))));
704 let email = try!(env::var(&email_var).or_else(
705 |_| config.get_string("user.email").or_else(
706 |_| env::var("EMAIL").or_else(
707 |_| Err(format!("Could not determine {} email: checked ${}, user.email in git config, and $EMAIL", which_lc, email_var))))));
708 Ok(try!(git2::Signature::now(&name, &email)))
709}
710
711fn commit_status(out: &mut Output, repo: &Repository, m: &ArgMatches, do_status: bool) -> Result<()> {
712 let config = try!(try!(repo.config()).snapshot());
713 let shead = match repo.find_reference(SHEAD_REF) {
714 Err(ref e) if e.code() == git2::ErrorCode::NotFound => { println!("No series; use \"git series start <name>\" to start"); return Ok(()); }
715 result => try!(result),
716 };
717 let series_name = try!(shead_series_name(&shead));
718
719 if do_status {
720 try!(out.auto_pager(&config, "status", false));
721 }
722 let get_color = |out: &Output, color: &str, default: &str| {
723 if do_status {
724 out.get_color(&config, "status", color, default)
725 } else {
726 Ok(Style::new())
727 }
728 };
729 let color_normal = Style::new();
730 let color_header = try!(get_color(out, "header", "normal"));
731 let color_updated = try!(get_color(out, "updated", "green"));
732 let color_changed = try!(get_color(out, "changed", "red"));
733
734 let write_status = |status: &mut Vec<ansi_term::ANSIString>, diff: &Diff, heading: &str, color: &Style, show_hints: bool, hints: &[&str]| -> Result<bool> {
735 let mut changes = false;
736
737 try!(diff.foreach(&mut |delta, _| {
738 if !changes {
739 changes = true;
740 status.push(color_header.paint(format!("{}\n", heading.to_string())));
741 if show_hints {
742 for hint in hints {
743 status.push(color_header.paint(format!(" ({})\n", hint)));
744 }
745 }
746 status.push(color_normal.paint("\n"));
747 }
748 status.push(color_normal.paint(" "));
749 status.push(color.paint(format!("{:?}: {}\n", delta.status(), delta.old_file().path().unwrap().to_str().unwrap())));
750 true
751 }, None, None, None));
752
753 if changes {
754 status.push(color_normal.paint("\n"));
755 }
756
757 Ok(changes)
758 };
759
760 let mut status = Vec::new();
761 status.push(color_header.paint(format!("On series {}\n", series_name)));
762
763 let mut internals = try!(Internals::read(repo));
764 let working_tree = try!(repo.find_tree(try!(internals.working.write())));
765 let staged_tree = try!(repo.find_tree(try!(internals.staged.write())));
766
767 let shead_commit = match shead.resolve() {
768 Ok(r) => Some(try!(peel_to_commit(r))),
769 Err(ref e) if e.code() == git2::ErrorCode::NotFound => {
770 status.push(color_header.paint("\nInitial series commit\n"));
771 None
772 }
773 Err(e) => try!(Err(e)),
774 };
775 let shead_tree = match shead_commit {
776 Some(ref c) => Some(try!(c.tree())),
777 None => None,
778 };
779
780 let commit_all = m.is_present("all");
781
782 let (changes, tree, diff) = if commit_all {
783 let diff = try!(repo.diff_tree_to_tree(shead_tree.as_ref(), Some(&working_tree), None));
784 let changes = try!(write_status(&mut status, &diff, "Changes to be committed:", &color_normal, false, &[]));
785 if !changes {
786 status.push(color_normal.paint("nothing to commit; series unchanged\n"));
787 }
788 (changes, working_tree, diff)
789 } else {
790 let diff = try!(repo.diff_tree_to_tree(shead_tree.as_ref(), Some(&staged_tree), None));
791 let changes_to_be_committed = try!(write_status(&mut status, &diff,
792 "Changes to be committed:", &color_updated, do_status,
793 &["use \"git series commit\" to commit",
794 "use \"git series unadd <file>...\" to undo add"]));
795
796 let diff_not_staged = try!(repo.diff_tree_to_tree(Some(&staged_tree), Some(&working_tree), None));
797 let changes_not_staged = try!(write_status(&mut status, &diff_not_staged,
798 "Changes not staged for commit:", &color_changed, do_status,
799 &["use \"git series add <file>...\" to update what will be committed"]));
800
801 if !changes_to_be_committed {
802 if changes_not_staged {
803 status.push(color_normal.paint("no changes added to commit (use \"git series add\" or \"git series commit -a\")\n"));
804 } else {
805 status.push(color_normal.paint("nothing to commit; series unchanged\n"));
806 }
807 }
808
809 (changes_to_be_committed, staged_tree, diff)
810 };
811
812 let status = ansi_term::ANSIStrings(&status).to_string();
813 if do_status || !changes {
814 if do_status {
815 try!(write!(out, "{}", status));
816 } else {
817 return Err(status.into());
818 }
819 return Ok(());
820 }
821
822 // Check that the commit includes the series
823 let series_id = match tree.get_name("series") {
824 None => { return Err(concat!("Cannot commit: initial commit must include \"series\"\n",
825 "Use \"git series add series\" or \"git series commit -a\"").into()); }
826 Some(series) => series.id()
827 };
828
829 // Check that the base is still an ancestor of the series
830 if let Some(base) = tree.get_name("base") {
831 if base.id() != series_id && !try!(repo.graph_descendant_of(series_id, base.id())) {
832 let (base_short_id, base_summary) = try!(commit_summarize_components(&repo, base.id()));
833 let (series_short_id, series_summary) = try!(commit_summarize_components(&repo, series_id));
834 return Err(format!(concat!(
835 "Cannot commit: base {} is not an ancestor of patch series {}\n",
836 "base {} {}\n",
837 "series {} {}"),
838 base_short_id, series_short_id,
839 base_short_id, base_summary,
840 series_short_id, series_summary).into());
841 }
842 }
843
844 let msg = match m.value_of("m") {
845 Some(s) => s.to_string(),
846 None => {
847 let filename = repo.path().join("SCOMMIT_EDITMSG");
848 let mut file = try!(File::create(&filename));
849 try!(write!(file, "{}", COMMIT_MESSAGE_COMMENT));
850 for line in status.lines() {
851 if line.is_empty() {
852 try!(writeln!(file, "#"));
853 } else {
854 try!(writeln!(file, "# {}", line));
855 }
856 }
857 if m.is_present("verbose") {
858 try!(writeln!(file, "{}\n{}", SCISSOR_LINE, SCISSOR_COMMENT));
859 try!(write_diff(&mut file, &diff));
860 }
861 drop(file);
862 try!(run_editor(&config, &filename));
863 let mut file = try!(File::open(&filename));
864 let mut msg = String::new();
865 try!(file.read_to_string(&mut msg));
866 if let Some(scissor_index) = msg.find(SCISSOR_LINE) {
867 msg.truncate(scissor_index);
868 }
869 try!(git2::message_prettify(msg, git2::DEFAULT_COMMENT_CHAR))
870 }
871 };
872 if msg.is_empty() {
873 return Err("Aborting series commit due to empty commit message.".into());
874 }
875
876 let author = try!(get_signature(&config, "AUTHOR"));
877 let committer = try!(get_signature(&config, "COMMITTER"));
878 let mut parents: Vec<Oid> = Vec::new();
879 // Include all commits from tree, to keep them reachable and fetchable.
880 for e in tree.iter() {
881 if e.kind() == Some(ObjectType::Commit) && e.name().unwrap() != "base" {
882 parents.push(e.id())
883 }
884 }
885 let parents = try!(parents_from_ids(repo, parents));
886 let parents_ref: Vec<&_> = shead_commit.iter().chain(parents.iter()).collect();
887 let new_commit_oid = try!(repo.commit(Some(SHEAD_REF), &author, &committer, &msg, &tree, &parents_ref));
888
889 if commit_all {
890 internals.staged = try!(repo.treebuilder(Some(&tree)));
891 try!(internals.write(repo));
892 }
893
894 let (new_commit_short_id, new_commit_summary) = try!(commit_summarize_components(&repo, new_commit_oid));
895 try!(writeln!(out, "[{} {}] {}", series_name, new_commit_short_id, new_commit_summary));
896
897 Ok(())
898}
899
900fn cover(repo: &Repository, m: &ArgMatches) -> Result<()> {
901 let mut internals = try!(Internals::read(repo));
902
903 let (working_cover_id, working_cover_content) = match try!(internals.working.get("cover")) {
904 None => (zero_oid(), String::new()),
905 Some(entry) => (entry.id(), try!(std::str::from_utf8(try!(repo.find_blob(entry.id())).content())).to_string()),
906 };
907
908 if m.is_present("delete") {
909 if working_cover_id.is_zero() {
910 return Err("No cover to delete".into());
911 }
912 try!(internals.working.remove("cover"));
913 try!(internals.write(repo));
914 println!("Deleted cover letter");
915 return Ok(());
916 }
917
918 let filename = repo.path().join("COVER_EDITMSG");
919 let mut file = try!(File::create(&filename));
920 if working_cover_content.is_empty() {
921 try!(write!(file, "{}", COVER_LETTER_COMMENT));
922 } else {
923 try!(write!(file, "{}", working_cover_content));
924 }
925 drop(file);
926 let config = try!(repo.config());
927 try!(run_editor(&config, &filename));
928 let mut file = try!(File::open(&filename));
929 let mut msg = String::new();
930 try!(file.read_to_string(&mut msg));
931 let msg = try!(git2::message_prettify(msg, git2::DEFAULT_COMMENT_CHAR));
932 if msg.is_empty() {
933 return Err("Empty cover letter; not changing.\n(To delete the cover letter, use \"git series -d\".)".into());
934 }
935
936 let new_cover_id = try!(repo.blob(msg.as_bytes()));
937 if new_cover_id == working_cover_id {
938 println!("Cover letter unchanged");
939 } else {
940 try!(internals.working.insert("cover", new_cover_id, GIT_FILEMODE_BLOB as i32));
941 try!(internals.write(repo));
942 println!("Updated cover letter");
943 }
944
945 Ok(())
946}
947
948fn date_822(t: git2::Time) -> String {
949 let offset = chrono::offset::fixed::FixedOffset::east(t.offset_minutes()*60);
950 let datetime = offset.timestamp(t.seconds(), 0);
951 datetime.to_rfc2822()
952}
953
954fn shortlog(commits: &mut [Commit]) -> String {
955 let mut s = String::new();
956 let mut author_map = std::collections::HashMap::new();
957
958 for mut commit in commits {
959 let author = commit.author().name().unwrap().to_string();
960 author_map.entry(author).or_insert(Vec::new()).push(commit.summary().unwrap().to_string());
961 }
962
963 let mut authors: Vec<_> = author_map.keys().collect();
964 authors.sort();
965 let mut first = true;
966 for author in authors {
967 if first {
968 first = false;
969 } else {
970 writeln!(s, "").unwrap();
971 }
972 let summaries = author_map.get(author).unwrap();
973 writeln!(s, "{} ({}):", author, summaries.len()).unwrap();
974 for summary in summaries {
975 writeln!(s, " {}", summary).unwrap();
976 }
977 }
978
979 s
980}
981
982fn ascii_isalnum(c: char) -> bool {
983 (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9')
984}
985
986fn sanitize_summary(summary: &str) -> String {
987 let mut s = String::with_capacity(summary.len());
988 let mut prev_dot = false;
989 let mut need_space = false;
990 for c in summary.chars() {
991 if ascii_isalnum(c) || c == '_' || c == '.' {
992 if need_space {
993 s.push('-');
994 need_space = false;
995 }
996 if !(prev_dot && c == '.') {
997 s.push(c);
998 }
999 } else {
1000 if !s.is_empty() {
1001 need_space = true;
1002 }
1003 }
1004 prev_dot = c == '.';
1005 }
1006 let end = s.trim_right_matches(|c| c == '.' || c == '-').len();
1007 s.truncate(end);
1008 s
1009}
1010
1011#[test]
1012fn test_sanitize_summary() {
1013 let tests = vec![
1014 ("", ""),
1015 ("!!!!!", ""),
1016 ("Test", "Test"),
1017 ("Test case", "Test-case"),
1018 ("Test case", "Test-case"),
1019 (" Test case ", "Test-case"),
1020 ("...Test...case...", ".Test.case"),
1021 ("...Test...case.!!", ".Test.case"),
1022 (".!.Test.!.case.!.", ".-.Test.-.case"),
1023 ];
1024 for (summary, sanitized) in tests {
1025 assert_eq!(sanitize_summary(summary), sanitized.to_string());
1026 }
1027}
1028
1029fn split_message(message: &str) -> (&str, &str) {
1030 let mut iter = message.splitn(2, '\n');
1031 let subject = iter.next().unwrap().trim_right();
1032 let body = iter.next().map(|s| s.trim_left()).unwrap_or("");
1033 (subject, body)
1034}
1035
1036fn diffstat(diff: &Diff) -> Result<String> {
1037 let stats = try!(diff.stats());
1038 let stats_buf = try!(stats.to_buf(git2::DIFF_STATS_FULL|git2::DIFF_STATS_INCLUDE_SUMMARY, 72));
1039 Ok(stats_buf.as_str().unwrap().to_string())
1040}
1041
1042fn write_diff<W: IoWrite>(f: &mut W, diff: &Diff) -> Result<()> {
1043 let mut err = Ok(());
1044 try!(diff.print(git2::DiffFormat::Patch, |_, _, l| {
1045 err = || -> Result<()> {
1046 let o = l.origin();
1047 if o == '+' || o == '-' || o == ' ' {
1048 try!(f.write_all(&[o as u8]));
1049 }
1050 try!(f.write_all(l.content()));
1051 Ok(())
1052 }();
1053 err.is_ok()
1054 }));
1055 err
1056}
1057
1058fn mail_signature() -> String {
1059 format!("-- \ngit-series {}", crate_version!())
1060}
1061
1062fn ensure_nl(s: &str) -> &'static str {
1063 if !s.ends_with('\n') {
1064 "\n"
1065 } else {
1066 ""
1067 }
1068}
1069
1070fn format(out: &mut Output, repo: &Repository, m: &ArgMatches) -> Result<()> {
1071 let config = try!(repo.config());
1072 let to_stdout = m.is_present("stdout");
1073
1074 let shead_commit = try!(peel_to_commit(try!(try!(repo.find_reference(SHEAD_REF)).resolve())));
1075 let stree = try!(shead_commit.tree());
1076
1077 let series = try!(stree.get_name("series").ok_or("Internal error: series did not contain \"series\""));
1078 let base = try!(stree.get_name("base").ok_or("Cannot format series; no base set.\nUse \"git series base\" to set base."));
1079
1080 let mut revwalk = try!(repo.revwalk());
1081 revwalk.set_sorting(git2::SORT_TOPOLOGICAL|git2::SORT_REVERSE);
1082 try!(revwalk.push(series.id()));
1083 try!(revwalk.hide(base.id()));
1084 let mut commits: Vec<Commit> = try!(revwalk.map(|c| {
1085 let id = try!(c);
1086 let commit = try!(repo.find_commit(id));
1087 if commit.parent_ids().count() > 1 {
1088 return Err(format!("Error: cannot format merge commit as patch:\n{}", try!(commit_summarize(repo, id))).into());
1089 }
1090 Ok(commit)
1091 }).collect::<Result<_>>());
1092 if commits.is_empty() {
1093 return Err("No patches to format; series and base identical.".into());
1094 }
1095
1096 let author = try!(get_signature(&config, "AUTHOR"));
1097 let author_name = author.name().unwrap();
1098 let author_email = author.email().unwrap();
1099 let message_id_suffix = format!("{}.git-series.{}", author.when().seconds(), author_email);
1100
1101 let cover_entry = stree.get_name("cover");
1102 let mut in_reply_to_message_id = m.value_of("in-reply-to").map(|v| {
1103 format!("{}{}{}",
1104 if v.starts_with('<') { "" } else { "<" },
1105 v,
1106 if v.ends_with('>') { "" } else { ">" })
1107 });
1108
1109 let signature = mail_signature();
1110
1111 let mut out : Box<IoWrite> = if to_stdout {
1112 try!(out.auto_pager(&config, "format-patch", true));
1113 Box::new(out)
1114 } else {
1115 Box::new(std::io::stdout())
1116 };
1117 let patch_file = |name: &str| -> Result<Box<IoWrite>> {
1118 println!("{}", name);
1119 Ok(Box::new(try!(File::create(name))))
1120 };
1121
1122 if let Some(ref entry) = cover_entry {
1123 let cover_blob = try!(repo.find_blob(entry.id()));
1124 let content = try!(std::str::from_utf8(cover_blob.content())).to_string();
1125 let (subject, body) = split_message(&content);
1126
1127 let series_tree = try!(repo.find_commit(series.id())).tree().unwrap();
1128 let base_tree = try!(repo.find_commit(base.id())).tree().unwrap();
1129 let diff = try!(repo.diff_tree_to_tree(Some(&base_tree), Some(&series_tree), None));
1130 let stats = try!(diffstat(&diff));
1131
1132 if !to_stdout {
1133 out = try!(patch_file("0000-cover-letter.patch"));
1134 }
1135 try!(writeln!(out, "From {} Mon Sep 17 00:00:00 2001", shead_commit.id()));
1136 let cover_message_id = format!("<cover.{}.{}>", shead_commit.id(), message_id_suffix);
1137 try!(writeln!(out, "Message-Id: {}", cover_message_id));
1138 if let Some(ref message_id) = in_reply_to_message_id {
1139 try!(writeln!(out, "In-Reply-To: {}", message_id));
1140 try!(writeln!(out, "References: {}", message_id));
1141 }
1142 in_reply_to_message_id = Some(cover_message_id);
1143 try!(writeln!(out, "From: {} <{}>", author_name, author_email));
1144 try!(writeln!(out, "Date: {}", date_822(author.when())));
1145 try!(writeln!(out, "Subject: [PATCH 0/{}] {}\n", commits.len(), subject));
1146 if !body.is_empty() {
1147 try!(writeln!(out, "{}", body));
1148 }
1149 try!(writeln!(out, "{}", shortlog(&mut commits)));
1150 try!(writeln!(out, "{}", stats));
1151 try!(writeln!(out, "{}", signature));
1152 }
1153
1154 for (commit_num, commit) in commits.iter().enumerate() {
1155 if to_stdout && (commit_num > 0 || cover_entry.is_some()) {
1156 try!(writeln!(out, ""));
1157 }
1158
1159 let message = commit.message().unwrap();
1160 let (subject, body) = split_message(message);
1161 let commit_id = commit.id();
1162 let commit_author = commit.author();
1163 let summary_sanitized = sanitize_summary(&subject);
1164 let this_message_id = format!("<{}.{}>", commit_id, message_id_suffix);
1165 let parent = try!(commit.parent(0));
1166 let diff = try!(repo.diff_tree_to_tree(Some(&parent.tree().unwrap()), Some(&commit.tree().unwrap()), None));
1167 let stats = try!(diffstat(&diff));
1168
1169 if !to_stdout {
1170 out = try!(patch_file(&format!("{:04}-{}.patch", commit_num+1, summary_sanitized)));
1171 }
1172 try!(writeln!(out, "From {} Mon Sep 17 00:00:00 2001", commit_id));
1173 try!(writeln!(out, "Message-Id: {}", this_message_id));
1174 if let Some(ref message_id) = in_reply_to_message_id {
1175 try!(writeln!(out, "In-Reply-To: {}", message_id));
1176 try!(writeln!(out, "References: {}", message_id));
1177 }
1178 if commit_num == 0 && cover_entry.is_none() {
1179 in_reply_to_message_id = Some(this_message_id);
1180 }
1181 try!(writeln!(out, "From: {} <{}>", author_name, author_email));
1182 try!(writeln!(out, "Date: {}", date_822(commit_author.when())));
1183 try!(writeln!(out, "Subject: [PATCH {}/{}] {}\n", commit_num+1, commits.len(), subject));
1184 if !body.is_empty() {
1185 try!(write!(out, "{}{}", body, ensure_nl(&body)));
1186 }
1187 try!(writeln!(out, "---"));
1188 try!(writeln!(out, "{}", stats));
1189 try!(write_diff(&mut out, &diff));
1190 try!(writeln!(out, "{}", signature));
1191 }
1192
1193 Ok(())
1194}
1195
1196fn log(out: &mut Output, repo: &Repository, m: &ArgMatches) -> Result<()> {
1197 let config = try!(try!(repo.config()).snapshot());
1198 try!(out.auto_pager(&config, "log", true));
1199 let color_commit = try!(out.get_color(&config, "diff", "commit", "yellow"));
1200
1201 let mut revwalk = try!(repo.revwalk());
1202 try!(revwalk.push_ref(SHEAD_REF));
1203
1204 // Walk once before sorting, to find all the commits to hide. Revwalk doesn't support hiding on
1205 // the fly when sorted.
1206 let mut hidden_ids = std::collections::HashSet::new();
1207 while let Some(oid) = revwalk.next() {
1208 let oid = try!(oid);
1209 let commit = try!(repo.find_commit(oid));
1210 let tree = try!(commit.tree());
1211 for parent_id in commit.parent_ids() {
1212 if tree.get_id(parent_id).is_some() {
1213 try!(revwalk.hide(parent_id));
1214 hidden_ids.insert(parent_id);
1215 }
1216 }
1217 }
1218
1219 // set_sorting resets the revwalk
1220 revwalk.set_sorting(git2::SORT_TOPOLOGICAL);
1221 try!(revwalk.push_ref(SHEAD_REF));
1222 for id in hidden_ids {
1223 try!(revwalk.hide(id));
1224 }
1225
1226 let show_diff = m.is_present("patch");
1227
1228 let mut first = true;
1229 for oid in revwalk {
1230 if first {
1231 first = false;
1232 } else {
1233 try!(writeln!(out, ""));
1234 }
1235 let oid = try!(oid);
1236 let commit = try!(repo.find_commit(oid));
1237 let author = commit.author();
1238
1239 try!(writeln!(out, "{}", color_commit.paint(format!("commit {}", oid))));
1240 try!(writeln!(out, "Author: {} <{}>", author.name().unwrap(), author.email().unwrap()));
1241 try!(writeln!(out, "Date: {}\n", date_822(author.when())));
1242 for line in commit.message().unwrap().lines() {
1243 try!(writeln!(out, " {}", line));
1244 }
1245
1246 if show_diff {
1247 let tree = try!(commit.tree());
1248 let parent_ids: Vec<_> = commit.parent_ids().take_while(|parent_id| tree.get_id(*parent_id).is_none()).collect();
1249
1250 try!(writeln!(out, ""));
1251 if parent_ids.len() > 1 {
1252 try!(writeln!(out, "(Diffs of series merge commits not yet supported)"));
1253 } else {
1254 let parent_tree = if parent_ids.len() == 0 {
1255 None
1256 } else {
1257 Some(try!(try!(repo.find_commit(parent_ids[0])).tree()))
1258 };
1259 let diff = try!(repo.diff_tree_to_tree(parent_tree.as_ref(), Some(&tree), None));
1260 try!(write_diff(out, &diff));
1261 }
1262 }
1263 }
1264
1265 Ok(())
1266}
1267
1268fn rebase(repo: &Repository, m: &ArgMatches) -> Result<()> {
1269 match repo.state() {
1270 git2::RepositoryState::Clean => (),
1271 git2::RepositoryState::RebaseMerge if repo.path().join("rebase-merge").join("git-series").exists() => {
1272 return Err("git series rebase already in progress.\nUse \"git rebase --continue\" or \"git rebase --abort\".".into());
1273 },
1274 s => { return Err(format!("{:?} in progress; cannot rebase", s).into()); }
1275 }
1276
1277 let internals = try!(Internals::read(repo));
1278 let series = try!(try!(internals.working.get("series")).ok_or("Could not find entry \"series\" in working index"));
1279 let base = try!(try!(internals.working.get("base")).ok_or("Cannot rebase series; no base set.\nUse \"git series base\" to set base."));
1280 if series.id() == base.id() {
1281 return Err("No patches to rebase; series and base identical.".into());
1282 } else if !try!(repo.graph_descendant_of(series.id(), base.id())) {
1283 return Err(format!("Cannot rebase: current base {} not an ancestor of series {}", base.id(), series.id()).into());
1284 }
1285
1286 // Check for unstaged or uncommitted changes before attempting to rebase.
1287 let series_commit = try!(repo.find_commit(series.id()));
1288 let series_tree = try!(series_commit.tree());
1289 let mut unclean = String::new();
1290 if !diff_empty(&try!(repo.diff_tree_to_index(Some(&series_tree), None, None))) {
1291 writeln!(unclean, "Cannot rebase: you have unstaged changes.").unwrap();
1292 }
1293 if !diff_empty(&try!(repo.diff_index_to_workdir(None, None))) {
1294 if unclean.is_empty() {
1295 writeln!(unclean, "Cannot rebase: your index contains uncommitted changes.").unwrap();
1296 } else {
1297 writeln!(unclean, "Additionally, your index contains uncommitted changes.").unwrap();
1298 }
1299 }
1300 if !unclean.is_empty() {
1301 return Err(unclean.into());
1302 }
1303
1304 let mut revwalk = try!(repo.revwalk());
1305 revwalk.set_sorting(git2::SORT_TOPOLOGICAL|git2::SORT_REVERSE);
1306 try!(revwalk.push(series.id()));
1307 try!(revwalk.hide(base.id()));
1308 let commits: Vec<Commit> = try!(revwalk.map(|c| {
1309 let id = try!(c);
1310 let mut commit = try!(repo.find_commit(id));
1311 if commit.parent_ids().count() > 1 {
1312 return Err(format!("Error: cannot rebase merge commit:\n{}", try!(commit_obj_summarize(&mut commit))).into());
1313 }
1314 Ok(commit)
1315 }).collect::<Result<_>>());
1316
1317 let interactive = m.is_present("interactive");
1318 let onto = match m.value_of("onto") {
1319 None => None,
1320 Some(onto) => {
1321 let obj = try!(repo.revparse_single(onto));
1322 Some(obj.id())
1323 },
1324 };
1325
1326 let newbase = onto.unwrap_or(base.id());
1327 let (base_short, _) = try!(commit_summarize_components(&repo, base.id()));
1328 let (newbase_short, _) = try!(commit_summarize_components(&repo, newbase));
1329 let (series_short, _) = try!(commit_summarize_components(&repo, series.id()));
1330
1331 let newbase_obj = try!(repo.find_commit(newbase)).into_object();
1332
1333 let dir = try!(TempDir::new_in(repo.path(), "rebase-merge"));
1334 let final_path = repo.path().join("rebase-merge");
1335 let mut create = std::fs::OpenOptions::new();
1336 create.write(true).create_new(true);
1337
1338 try!(create.open(dir.path().join("git-series")));
1339 try!(create.open(dir.path().join("quiet")));
1340 try!(create.open(dir.path().join("interactive")));
1341
1342 let mut head_name_file = try!(create.open(dir.path().join("head-name")));
1343 try!(writeln!(head_name_file, "detached HEAD"));
1344
1345 let mut onto_file = try!(create.open(dir.path().join("onto")));
1346 try!(writeln!(onto_file, "{}", newbase));
1347
1348 let mut orig_head_file = try!(create.open(dir.path().join("orig-head")));
1349 try!(writeln!(orig_head_file, "{}", series.id()));
1350
1351 let git_rebase_todo_filename = dir.path().join("git-rebase-todo");
1352 let mut git_rebase_todo = try!(create.open(&git_rebase_todo_filename));
1353 for mut commit in commits {
1354 try!(writeln!(git_rebase_todo, "pick {}", try!(commit_obj_summarize(&mut commit))));
1355 }
1356 if let Some(onto) = onto {
1357 try!(writeln!(git_rebase_todo, "exec git series base {}", onto));
1358 }
1359 try!(writeln!(git_rebase_todo, "\n# Rebase {}..{} onto {}", base_short, series_short, newbase_short));
1360 try!(write!(git_rebase_todo, "{}", REBASE_COMMENT));
1361 drop(git_rebase_todo);
1362
1363 // Interactive editor if interactive {
1364 if interactive {
1365 let config = try!(repo.config());
1366 try!(run_editor(&config, &git_rebase_todo_filename));
1367 let mut file = try!(File::open(&git_rebase_todo_filename));
1368 let mut todo = String::new();
1369 try!(file.read_to_string(&mut todo));
1370 let todo = try!(git2::message_prettify(todo, git2::DEFAULT_COMMENT_CHAR));
1371 if todo.is_empty() {
1372 return Err("Nothing to do".into());
1373 }
1374 }
1375
1376 // Avoid races by not calling .into_path until after the rename succeeds.
1377 try!(std::fs::rename(dir.path(), final_path));
1378 dir.into_path();
1379
1380 try!(checkout_tree(repo, &newbase_obj));
1381 try!(repo.reference("HEAD", newbase, true, &format!("rebase -i (start): checkout {}", newbase)));
1382
1383 let status = try!(Command::new("git").arg("rebase").arg("--continue").status());
1384 if !status.success() {
1385 return Err(format!("git rebase --continue exited with status {}", status).into());
1386 }
1387
1388 Ok(())
1389}
1390
1391fn req(out: &mut Output, repo: &Repository, m: &ArgMatches) -> Result<()> {
1392 let config = try!(repo.config());
1393 let shead = try!(repo.find_reference(SHEAD_REF));
1394 let shead_commit = try!(peel_to_commit(try!(shead.resolve())));
1395 let stree = try!(shead_commit.tree());
1396
1397 let series = try!(stree.get_name("series").ok_or("Internal error: series did not contain \"series\""));
1398 let series_id = series.id();
1399 let mut series_commit = try!(repo.find_commit(series_id));
1400 let base = try!(stree.get_name("base").ok_or("Cannot request pull; no base set.\nUse \"git series base\" to set base."));
1401 let mut base_commit = try!(repo.find_commit(base.id()));
1402
1403 let (cover_content, subject, cover_body) = if let Some(entry) = stree.get_name("cover") {
1404 let cover_blob = try!(repo.find_blob(entry.id()));
1405 let content = try!(std::str::from_utf8(cover_blob.content())).to_string();
1406 let (subject, body) = split_message(&content);
1407 (Some(content.to_string()), subject.to_string(), Some(body.to_string()))
1408 } else {
1409 (None, try!(shead_series_name(&shead)), None)
1410 };
1411
1412 let url = m.value_of("url").unwrap();
1413 let tag = m.value_of("tag").unwrap();
1414 let full_tag = format!("refs/tags/{}", tag);
1415 let full_tag_peeled = format!("{}^{{}}", full_tag);
1416 let full_head = format!("refs/heads/{}", tag);
1417 let mut remote = try!(repo.remote_anonymous(url));
1418 try!(remote.connect(git2::Direction::Fetch).map_err(|e| format!("Could not connect to remote repository {}\n{}", url, e)));
1419 let remote_heads = try!(remote.list());
1420
1421 /* Find the requested name as either a tag or head */
1422 let mut opt_remote_tag = None;
1423 let mut opt_remote_tag_peeled = None;
1424 let mut opt_remote_head = None;
1425 for h in remote_heads {
1426 if h.name() == full_tag {
1427 opt_remote_tag = Some(h.oid());
1428 } else if h.name() == full_tag_peeled {
1429 opt_remote_tag_peeled = Some(h.oid());
1430 } else if h.name() == full_head {
1431 opt_remote_head = Some(h.oid());
1432 }
1433 }
1434 let (msg, extra_body, remote_pull_name) = match (opt_remote_tag, opt_remote_tag_peeled, opt_remote_head) {
1435 (Some(remote_tag), Some(remote_tag_peeled), _) => {
1436 if remote_tag_peeled != series_id {
1437 return Err(format!("Remote tag {} does not refer to series {}", tag, series_id).into());
1438 }
1439 let local_tag = try!(repo.find_tag(remote_tag).map_err(|e|
1440 format!("Could not find remote tag {} ({}) in local repository: {}", tag, remote_tag, e)));
1441 let mut local_tag_msg = local_tag.message().unwrap().to_string();
1442 if let Some(sig_index) = local_tag_msg.find("-----BEGIN PGP ") {
1443 local_tag_msg.truncate(sig_index);
1444 }
1445 let extra_body = match cover_content {
1446 Some(ref content) if !local_tag_msg.contains(content) => cover_body,
1447 _ => None,
1448 };
1449 (Some(local_tag_msg), extra_body, full_tag)
1450 },
1451 (Some(remote_tag), None, _) => {
1452 if remote_tag != series_id {
1453 return Err(format!("Remote unannotated tag {} does not refer to series {}", tag, series_id).into());
1454 }
1455 (cover_content, None, full_tag)
1456 }
1457 (_, _, Some(remote_head)) => {
1458 if remote_head != series_id {
1459 return Err(format!("Remote branch {} does not refer to series {}", tag, series_id).into());
1460 }
1461 (cover_content, None, full_head)
1462 },
1463 _ => {
1464 return Err(format!("Remote does not have either a tag or branch named {}", tag).into())
1465 }
1466 };
1467
1468 let commit_subject_date = |commit: &mut Commit| -> String {
1469 let date = date_822(commit.author().when());
1470 let summary = commit.summary().unwrap();
1471 format!(" {} ({})", summary, date)
1472 };
1473
1474 let mut revwalk = try!(repo.revwalk());
1475 revwalk.set_sorting(git2::SORT_TOPOLOGICAL|git2::SORT_REVERSE);
1476 try!(revwalk.push(series_id));
1477 try!(revwalk.hide(base.id()));
1478 let mut commits: Vec<Commit> = try!(revwalk.map(|c| {
1479 Ok(try!(repo.find_commit(try!(c))))
1480 }).collect::<Result<_>>());
1481 if commits.is_empty() {
1482 return Err("No patches to request pull of; series and base identical.".into());
1483 }
1484
1485 let author = try!(get_signature(&config, "AUTHOR"));
1486 let author_email = author.email().unwrap();
1487 let message_id = format!("<pull.{}.{}.git-series.{}>", shead_commit.id(), author.when().seconds(), author_email);
1488
1489 let diff = try!(repo.diff_tree_to_tree(Some(&base_commit.tree().unwrap()), Some(&series_commit.tree().unwrap()), None));
1490 let stats = try!(diffstat(&diff));
1491
1492 try!(out.auto_pager(&config, "request-pull", true));
1493 try!(writeln!(out, "From {} Mon Sep 17 00:00:00 2001", shead_commit.id()));
1494 try!(writeln!(out, "Message-Id: {}", message_id));
1495 try!(writeln!(out, "From: {} <{}>", author.name().unwrap(), author_email));
1496 try!(writeln!(out, "Date: {}", date_822(author.when())));
1497 try!(writeln!(out, "Subject: [GIT PULL] {}\n", subject));
1498 if let Some(extra_body) = extra_body {
1499 try!(writeln!(out, "{}", extra_body));
1500 }
1501 try!(writeln!(out, "The following changes since commit {}:\n", base.id()));
1502 try!(writeln!(out, "{}\n", commit_subject_date(&mut base_commit)));
1503 try!(writeln!(out, "are available in the git repository at:\n"));
1504 try!(writeln!(out, " {} {}\n", url, remote_pull_name));
1505 try!(writeln!(out, "for you to fetch changes up to {}:\n", series.id()));
1506 try!(writeln!(out, "{}\n", commit_subject_date(&mut series_commit)));
1507 try!(writeln!(out, "----------------------------------------------------------------"));
1508 if let Some(msg) = msg {
1509 try!(writeln!(out, "{}", msg));
1510 try!(writeln!(out, "----------------------------------------------------------------"));
1511 }
1512 try!(writeln!(out, "{}", shortlog(&mut commits)));
1513 try!(writeln!(out, "{}", stats));
1514 if m.is_present("patch") {
1515 try!(write_diff(out, &diff));
1516 }
1517 try!(writeln!(out, "{}", mail_signature()));
1518
1519 Ok(())
1520}
1521
1522fn main() {
1523 let m = App::new("git-series")
1524 .bin_name("git series")
1525 .about("Track patch series in git")
1526 .author("Josh Triplett <josh@joshtriplett.org>")
1527 .version(crate_version!())
1528 .global_setting(AppSettings::ColoredHelp)
1529 .global_setting(AppSettings::VersionlessSubcommands)
1530 .subcommands(vec![
1531 SubCommand::with_name("add")
1532 .about("Add changes to the index for the next series commit")
1533 .arg_from_usage("<change>... 'Changes to add (\"series\", \"base\", \"cover\")'"),
1534 SubCommand::with_name("base")
1535 .about("Get or set the base commit for the patch series")
1536 .arg(Arg::with_name("base").help("Base commit").conflicts_with("delete"))
1537 .arg_from_usage("-d, --delete 'Clear patch series base'"),
1538 SubCommand::with_name("checkout")
1539 .about("Resume work on a patch series; check out the current version")
1540 .arg_from_usage("<name> 'Patch series to check out'"),
1541 SubCommand::with_name("commit")
1542 .about("Record changes to the patch series")
1543 .arg_from_usage("-a, --all 'Commit all changes'")
1544 .arg_from_usage("-m [msg] 'Commit message'")
1545 .arg_from_usage("-v, --verbose 'Show diff when preparing commit message'"),
1546 SubCommand::with_name("cover")
1547 .about("Create or edit the cover letter for the patch series")
1548 .arg_from_usage("-d, --delete 'Delete cover letter'"),
1549 SubCommand::with_name("delete")
1550 .about("Delete a patch series")
1551 .arg_from_usage("<name> 'Patch series to delete'"),
1552 SubCommand::with_name("detach")
1553 .about("Stop working on any patch series"),
1554 SubCommand::with_name("format")
1555 .about("Prepare patch series for email")
1556 .arg_from_usage("--in-reply-to [Message-Id] 'Make the first mail a reply to the specified Message-Id'")
1557 .arg_from_usage("--stdout 'Write patches to stdout rather than files'"),
1558 SubCommand::with_name("log")
1559 .about("Show the history of the patch series")
1560 .arg_from_usage("-p, --patch 'Include a patch for each change committed to the series'"),
1561 SubCommand::with_name("rebase")
1562 .about("Rebase the patch series")
1563 .arg_from_usage("[onto] 'Commit to rebase onto'")
1564 .arg_from_usage("-i, --interactive 'Interactively edit the list of commits'")
1565 .group(ArgGroup::with_name("action").args(&["onto", "interactive"]).multiple(true).required(true)),
1566 SubCommand::with_name("req")
1567 .about("Generate a mail requesting a pull of the patch series")
1568 .visible_aliases(&["pull-request", "request-pull"])
1569 .arg_from_usage("-p, --patch 'Include patch in the mail'")
1570 .arg_from_usage("<url> 'Repository URL to request pull of'")
1571 .arg_from_usage("<tag> 'Tag or branch name to request pull of'"),
1572 SubCommand::with_name("status")
1573 .about("Show the status of the patch series"),
1574 SubCommand::with_name("start")
1575 .about("Start a new patch series")
1576 .arg_from_usage("<name> 'Patch series name'"),
1577 SubCommand::with_name("unadd")
1578 .about("Undo \"git series add\", removing changes from the next series commit")
1579 .arg_from_usage("<change>... 'Changes to remove (\"series\", \"base\", \"cover\")'"),
1580 ]).get_matches();
1581
1582 let mut out = Output::new();
1583
1584 let err = || -> Result<()> {
1585 let repo = try!(Repository::discover("."));
1586 match m.subcommand() {
1587 ("", _) => series(&mut out, &repo),
1588 ("add", Some(ref sm)) => add(&repo, &sm),
1589 ("base", Some(ref sm)) => base(&repo, &sm),
1590 ("checkout", Some(ref sm)) => checkout(&repo, &sm),
1591 ("commit", Some(ref sm)) => commit_status(&mut out, &repo, &sm, false),
1592 ("cover", Some(ref sm)) => cover(&repo, &sm),
1593 ("delete", Some(ref sm)) => delete(&repo, &sm),
1594 ("detach", _) => detach(&repo),
1595 ("format", Some(ref sm)) => format(&mut out, &repo, &sm),
1596 ("log", Some(ref sm)) => log(&mut out, &repo, &sm),
1597 ("rebase", Some(ref sm)) => rebase(&repo, &sm),
1598 ("req", Some(ref sm)) => req(&mut out, &repo, &sm),
1599 ("start", Some(ref sm)) => start(&repo, &sm),
1600 ("status", Some(ref sm)) => commit_status(&mut out, &repo, &sm, true),
1601 ("unadd", Some(ref sm)) => unadd(&repo, &sm),
1602 _ => unreachable!()
1603 }
1604 }();
1605
1606 if let Err(e) = err {
1607 let msg = e.to_string();
1608 out.write_err(&format!("{}{}", msg, ensure_nl(&msg)));
1609 drop(out);
1610 std::process::exit(1);
1611 }
1612}