/*

* Builtin "git commit"

*

* Copyright (c) 2007 Kristian Høgsberg <krh@redhat.com>

* Based on git-commit.sh by Junio C Hamano and Linus Torvalds

*/

#include "cache.h"

#include "lockfile.h"

#include "cache-tree.h"

#include "color.h"

#include "dir.h"

#include "builtin.h"

#include "diff.h"

#include "diffcore.h"

#include "commit.h"

#include "revision.h"

#include "wt-status.h"

#include "run-command.h"

#include "refs.h"

#include "log-tree.h"

#include "strbuf.h"

#include "utf8.h"

#include "parse-options.h"

#include "string-list.h"

#include "rerere.h"

#include "unpack-trees.h"

#include "quote.h"

#include "submodule.h"

#include "gpg-interface.h"

#include "column.h"

#include "sequencer.h"

#include "notes-utils.h"

#include "mailmap.h"

static const char * const builtin_commit_usage[] = {

N_("git commit [<options>] [--] <pathspec>..."),

NULL

};

static const char * const builtin_status_usage[] = {

N_("git status [<options>] [--] <pathspec>..."),

NULL

};

static const char implicit_ident_advice_noconfig[] =

N_("Your name and email address were configured automatically based\n"

"on your username and hostname. Please check that they are accurate.\n"

"You can suppress this message by setting them explicitly. Run the\n"

"following command and follow the instructions in your editor to edit\n"

"your configuration file:\n"

"\n"

" git config --global --edit\n"

"\n"

"After doing this, you may fix the identity used for this commit with:\n"

"\n"

" git commit --amend --reset-author\n");

static const char implicit_ident_advice_config[] =

N_("Your name and email address were configured automatically based\n"

"on your username and hostname. Please check that they are accurate.\n"

"You can suppress this message by setting them explicitly:\n"

"\n"

" git config --global user.name \"Your Name\"\n"

" git config --global user.email you@example.com\n"

"\n"

"After doing this, you may fix the identity used for this commit with:\n"

"\n"

" git commit --amend --reset-author\n");

static const char empty_amend_advice[] =

N_("You asked to amend the most recent commit, but doing so would make\n"

"it empty. You can repeat your command with --allow-empty, or you can\n"

"remove the commit entirely with \"git reset HEAD^\".\n");

static const char empty_cherry_pick_advice[] =

N_("The previous cherry-pick is now empty, possibly due to conflict resolution.\n"

"If you wish to commit it anyway, use:\n"

"\n"

" git commit --allow-empty\n"

"\n");

static const char empty_cherry_pick_advice_single[] =

N_("Otherwise, please use 'git reset'\n");

static const char empty_cherry_pick_advice_multi[] =

N_("If you wish to skip this commit, use:\n"

"\n"

" git reset\n"

"\n"

"Then \"git cherry-pick --continue\" will resume cherry-picking\n"

"the remaining commits.\n");

static const char *use_message_buffer;

static const char commit_editmsg[] = "COMMIT_EDITMSG";

static struct lock_file index_lock; /* real index */

static struct lock_file false_lock; /* used only for partial commits */

static enum {

COMMIT_AS_IS = 1,

COMMIT_NORMAL,

COMMIT_PARTIAL

} commit_style;

static const char *logfile, *force_author;

static const char *template_file;

/*

* The _message variables are commit names from which to take

* the commit message and/or authorship.

*/

static const char *author_message, *author_message_buffer;

static char *edit_message, *use_message;

static char *fixup_message, *squash_message;

static int all, also, interactive, patch_interactive, only, amend, signoff;

static int edit_flag = -1; /* unspecified */

static int quiet, verbose, no_verify, allow_empty, dry_run, renew_authorship;

static int no_post_rewrite, allow_empty_message;

static char *untracked_files_arg, *force_date, *ignore_submodule_arg;

static char *sign_commit;

/*

* The default commit message cleanup mode will remove the lines

* beginning with # (shell comments) and leading and trailing

* whitespaces (empty lines or containing only whitespaces)

* if editor is used, and only the whitespaces if the message

* is specified explicitly.

*/

static enum {

CLEANUP_SPACE,

CLEANUP_NONE,

CLEANUP_SCISSORS,

CLEANUP_ALL

} cleanup_mode;

static const char *cleanup_arg;

static enum commit_whence whence;

static int sequencer_in_use;

static int use_editor = 1, include_status = 1;

static int show_ignored_in_status, have_option_m;

static const char *only_include_assumed;

static struct strbuf message = STRBUF_INIT;

static enum status_format {

STATUS_FORMAT_NONE = 0,

STATUS_FORMAT_LONG,

STATUS_FORMAT_SHORT,

STATUS_FORMAT_PORCELAIN,

STATUS_FORMAT_UNSPECIFIED

} status_format = STATUS_FORMAT_UNSPECIFIED;

static int opt_parse_m(const struct option *opt, const char *arg, int unset)

{

struct strbuf *buf = opt->value;

if (unset) {

have_option_m = 0;

strbuf_setlen(buf, 0);

} else {

have_option_m = 1;

if (buf->len)

strbuf_addch(buf, '\n');

strbuf_addstr(buf, arg);

strbuf_complete_line(buf);

}

return 0;

}

static void determine_whence(struct wt_status *s)

{

if (file_exists(git_path("MERGE_HEAD")))

whence = FROM_MERGE;

else if (file_exists(git_path("CHERRY_PICK_HEAD"))) {

whence = FROM_CHERRY_PICK;

if (file_exists(git_path("sequencer")))

sequencer_in_use = 1;

}

else

whence = FROM_COMMIT;

if (s)

s->whence = whence;

}

static void status_init_config(struct wt_status *s, config_fn_t fn)

{

wt_status_prepare(s);

gitmodules_config();

git_config(fn, s);

determine_whence(s);

s->hints = advice_status_hints; /* must come after git_config() */

}

static void rollback_index_files(void)

{

switch (commit_style) {

case COMMIT_AS_IS:

break; /* nothing to do */

case COMMIT_NORMAL:

rollback_lock_file(&index_lock);

break;

case COMMIT_PARTIAL:

rollback_lock_file(&index_lock);

rollback_lock_file(&false_lock);

break;

}

}

static int commit_index_files(void)

{

int err = 0;

switch (commit_style) {

case COMMIT_AS_IS:

break; /* nothing to do */

case COMMIT_NORMAL:

err = commit_lock_file(&index_lock);

break;

case COMMIT_PARTIAL:

err = commit_lock_file(&index_lock);

rollback_lock_file(&false_lock);

break;

}

return err;

}

/*

* Take a union of paths in the index and the named tree (typically, "HEAD"),

* and return the paths that match the given pattern in list.

*/

static int list_paths(struct string_list *list, const char *with_tree,

const char *prefix, const struct pathspec *pattern)

{

int i, ret;

char *m;

if (!pattern->nr)

return 0;

m = xcalloc(1, pattern->nr);

if (with_tree) {

char *max_prefix = common_prefix(pattern);

overlay_tree_on_cache(with_tree, max_prefix ? max_prefix : prefix);

free(max_prefix);

}

for (i = 0; i < active_nr; i++) {

const struct cache_entry *ce = active_cache[i];

struct string_list_item *item;

if (ce->ce_flags & CE_UPDATE)

continue;

if (!ce_path_match(ce, pattern, m))

continue;

item = string_list_insert(list, ce->name);

if (ce_skip_worktree(ce))

item->util = item; /* better a valid pointer than a fake one */

}

ret = report_path_error(m, pattern, prefix);

free(m);

return ret;

}

static void add_remove_files(struct string_list *list)

{

int i;

for (i = 0; i < list->nr; i++) {

struct stat st;

struct string_list_item *p = &(list->items[i]);

/* p->util is skip-worktree */

if (p->util)

continue;

if (!lstat(p->string, &st)) {

if (add_to_cache(p->string, &st, 0))

die(_("updating files failed"));

} else

remove_file_from_cache(p->string);

}

}

static void create_base_index(const struct commit *current_head)

{

struct tree *tree;

struct unpack_trees_options opts;

struct tree_desc t;

if (!current_head) {

discard_cache();

return;

}

memset(&opts, 0, sizeof(opts));

opts.head_idx = 1;

opts.index_only = 1;

opts.merge = 1;

opts.src_index = &the_index;

opts.dst_index = &the_index;

opts.fn = oneway_merge;

tree = parse_tree_indirect(current_head->object.sha1);

if (!tree)

die(_("failed to unpack HEAD tree object"));

parse_tree(tree);

init_tree_desc(&t, tree->buffer, tree->size);

if (unpack_trees(1, &t, &opts))

exit(128); /* We've already reported the error, finish dying */

}

static void refresh_cache_or_die(int refresh_flags)

{

/*

* refresh_flags contains REFRESH_QUIET, so the only errors

* are for unmerged entries.

*/

if (refresh_cache(refresh_flags | REFRESH_IN_PORCELAIN))

die_resolve_conflict("commit");

}

static const char *prepare_index(int argc, const char **argv, const char *prefix,

const struct commit *current_head, int is_status)

{

struct string_list partial;

struct pathspec pathspec;

int refresh_flags = REFRESH_QUIET;

if (is_status)

refresh_flags |= REFRESH_UNMERGED;

parse_pathspec(&pathspec, 0,

PATHSPEC_PREFER_FULL,

prefix, argv);

if (read_cache_preload(&pathspec) < 0)

die(_("index file corrupt"));

if (interactive) {

char *old_index_env = NULL;

hold_locked_index(&index_lock, 1);

refresh_cache_or_die(refresh_flags);

if (write_locked_index(&the_index, &index_lock, CLOSE_LOCK))

die(_("unable to create temporary index"));

old_index_env = getenv(INDEX_ENVIRONMENT);

setenv(INDEX_ENVIRONMENT, index_lock.filename.buf, 1);

if (interactive_add(argc, argv, prefix, patch_interactive) != 0)

die(_("interactive add failed"));

if (old_index_env && *old_index_env)

setenv(INDEX_ENVIRONMENT, old_index_env, 1);

else

unsetenv(INDEX_ENVIRONMENT);

discard_cache();

read_cache_from(index_lock.filename.buf);

if (update_main_cache_tree(WRITE_TREE_SILENT) == 0) {

if (reopen_lock_file(&index_lock) < 0)

die(_("unable to write index file"));

if (write_locked_index(&the_index, &index_lock, CLOSE_LOCK))

die(_("unable to update temporary index"));

} else

warning(_("Failed to update main cache tree"));

commit_style = COMMIT_NORMAL;

return index_lock.filename.buf;

}

/*

* Non partial, non as-is commit.

*

* (1) get the real index;

* (2) update the_index as necessary;

* (3) write the_index out to the real index (still locked);

* (4) return the name of the locked index file.

*

* The caller should run hooks on the locked real index, and

* (A) if all goes well, commit the real index;

* (B) on failure, rollback the real index.

*/

if (all || (also && pathspec.nr)) {

hold_locked_index(&index_lock, 1);

add_files_to_cache(also ? prefix : NULL, &pathspec, 0);

refresh_cache_or_die(refresh_flags);

update_main_cache_tree(WRITE_TREE_SILENT);

if (write_locked_index(&the_index, &index_lock, CLOSE_LOCK))

die(_("unable to write new_index file"));

commit_style = COMMIT_NORMAL;

return index_lock.filename.buf;

}

/*

* As-is commit.

*

* (1) return the name of the real index file.

*

* The caller should run hooks on the real index,

* and create commit from the_index.

* We still need to refresh the index here.

*/

if (!only && !pathspec.nr) {

hold_locked_index(&index_lock, 1);

refresh_cache_or_die(refresh_flags);

if (active_cache_changed

|| !cache_tree_fully_valid(active_cache_tree)) {

update_main_cache_tree(WRITE_TREE_SILENT);

active_cache_changed = 1;

}

if (active_cache_changed) {

if (write_locked_index(&the_index, &index_lock,

COMMIT_LOCK))

die(_("unable to write new_index file"));

} else {

rollback_lock_file(&index_lock);

}

commit_style = COMMIT_AS_IS;

return get_index_file();

}

/*

* A partial commit.

*

* (0) find the set of affected paths;

* (1) get lock on the real index file;

* (2) update the_index with the given paths;

* (3) write the_index out to the real index (still locked);

* (4) get lock on the false index file;

* (5) reset the_index from HEAD;

* (6) update the_index the same way as (2);

* (7) write the_index out to the false index file;

* (8) return the name of the false index file (still locked);

*

* The caller should run hooks on the locked false index, and

* create commit from it. Then

* (A) if all goes well, commit the real index;

* (B) on failure, rollback the real index;

* In either case, rollback the false index.

*/

commit_style = COMMIT_PARTIAL;

if (whence != FROM_COMMIT) {

if (whence == FROM_MERGE)

die(_("cannot do a partial commit during a merge."));

else if (whence == FROM_CHERRY_PICK)

die(_("cannot do a partial commit during a cherry-pick."));

}

string_list_init(&partial, 1);

if (list_paths(&partial, !current_head ? NULL : "HEAD", prefix, &pathspec))

exit(1);

discard_cache();

if (read_cache() < 0)

die(_("cannot read the index"));

hold_locked_index(&index_lock, 1);

add_remove_files(&partial);

refresh_cache(REFRESH_QUIET);

update_main_cache_tree(WRITE_TREE_SILENT);

if (write_locked_index(&the_index, &index_lock, CLOSE_LOCK))

die(_("unable to write new_index file"));

hold_lock_file_for_update(&false_lock,

git_path("next-index-%"PRIuMAX,

(uintmax_t) getpid()),

LOCK_DIE_ON_ERROR);

create_base_index(current_head);

add_remove_files(&partial);

refresh_cache(REFRESH_QUIET);

if (write_locked_index(&the_index, &false_lock, CLOSE_LOCK))

die(_("unable to write temporary index file"));

discard_cache();

read_cache_from(false_lock.filename.buf);

return false_lock.filename.buf;

}

static int run_status(FILE *fp, const char *index_file, const char *prefix, int nowarn,

struct wt_status *s)

{

unsigned char sha1[20];

if (s->relative_paths)

s->prefix = prefix;

if (amend) {

s->amend = 1;

s->reference = "HEAD^1";

}

s->verbose = verbose;

s->index_file = index_file;

s->fp = fp;

s->nowarn = nowarn;

s->is_initial = get_sha1(s->reference, sha1) ? 1 : 0;

wt_status_collect(s);

switch (status_format) {

case STATUS_FORMAT_SHORT:

wt_shortstatus_print(s);

break;

case STATUS_FORMAT_PORCELAIN:

wt_porcelain_print(s);

break;

case STATUS_FORMAT_UNSPECIFIED:

die("BUG: finalize_deferred_config() should have been called");

break;

case STATUS_FORMAT_NONE:

case STATUS_FORMAT_LONG:

wt_status_print(s);

break;

}

return s->commitable;

}

static int is_a_merge(const struct commit *current_head)

{

return !!(current_head->parents && current_head->parents->next);

}

static void assert_split_ident(struct ident_split *id, const struct strbuf *buf)

{

if (split_ident_line(id, buf->buf, buf->len) || !id->date_begin)

die("BUG: unable to parse our own ident: %s", buf->buf);

}

static void export_one(const char *var, const char *s, const char *e, int hack)

{

struct strbuf buf = STRBUF_INIT;

if (hack)

strbuf_addch(&buf, hack);

strbuf_addf(&buf, "%.*s", (int)(e - s), s);

setenv(var, buf.buf, 1);

strbuf_release(&buf);

}

static int parse_force_date(const char *in, struct strbuf *out)

{

strbuf_addch(out, '@');

if (parse_date(in, out) < 0) {

int errors = 0;

unsigned long t = approxidate_careful(in, &errors);

if (errors)

return -1;

strbuf_addf(out, "%lu", t);

}

return 0;

}

static void set_ident_var(char **buf, char *val)

{

free(*buf);

*buf = val;

}

static void determine_author_info(struct strbuf *author_ident)

{

char *name, *email, *date;

struct ident_split author;

name = xstrdup_or_null(getenv("GIT_AUTHOR_NAME"));

email = xstrdup_or_null(getenv("GIT_AUTHOR_EMAIL"));

date = xstrdup_or_null(getenv("GIT_AUTHOR_DATE"));

if (author_message) {

struct ident_split ident;

size_t len;

const char *a;

a = find_commit_header(author_message_buffer, "author", &len);

if (!a)

die(_("commit '%s' lacks author header"), author_message);

if (split_ident_line(&ident, a, len) < 0)

die(_("commit '%s' has malformed author line"), author_message);

set_ident_var(&name, xmemdupz(ident.name_begin, ident.name_end - ident.name_begin));

set_ident_var(&email, xmemdupz(ident.mail_begin, ident.mail_end - ident.mail_begin));

if (ident.date_begin) {

struct strbuf date_buf = STRBUF_INIT;

strbuf_addch(&date_buf, '@');

strbuf_add(&date_buf, ident.date_begin, ident.date_end - ident.date_begin);

strbuf_addch(&date_buf, ' ');

strbuf_add(&date_buf, ident.tz_begin, ident.tz_end - ident.tz_begin);

set_ident_var(&date, strbuf_detach(&date_buf, NULL));

}

}

if (force_author) {

struct ident_split ident;

if (split_ident_line(&ident, force_author, strlen(force_author)) < 0)

die(_("malformed --author parameter"));

set_ident_var(&name, xmemdupz(ident.name_begin, ident.name_end - ident.name_begin));

set_ident_var(&email, xmemdupz(ident.mail_begin, ident.mail_end - ident.mail_begin));

}

if (force_date) {

struct strbuf date_buf = STRBUF_INIT;

if (parse_force_date(force_date, &date_buf))

die(_("invalid date format: %s"), force_date);

set_ident_var(&date, strbuf_detach(&date_buf, NULL));

}

strbuf_addstr(author_ident, fmt_ident(name, email, date, IDENT_STRICT));

assert_split_ident(&author, author_ident);

export_one("GIT_AUTHOR_NAME", author.name_begin, author.name_end, 0);

export_one("GIT_AUTHOR_EMAIL", author.mail_begin, author.mail_end, 0);

export_one("GIT_AUTHOR_DATE", author.date_begin, author.tz_end, '@');

free(name);

free(email);

free(date);

}

static int author_date_is_interesting(void)

{

return author_message || force_date;

}

static void adjust_comment_line_char(const struct strbuf *sb)

{

char candidates[] = "#;@!$%^&|:";

char *candidate;

const char *p;

comment_line_char = candidates[0];

if (!memchr(sb->buf, comment_line_char, sb->len))

return;

p = sb->buf;

candidate = strchr(candidates, *p);

if (candidate)

*candidate = ' ';

for (p = sb->buf; *p; p++) {

if ((p[0] == '\n' || p[0] == '\r') && p[1]) {

candidate = strchr(candidates, p[1]);

if (candidate)

*candidate = ' ';

}

}

for (p = candidates; *p == ' '; p++)

;

if (!*p)

die(_("unable to select a comment character that is not used\n"

"in the current commit message"));

comment_line_char = *p;

}

static int prepare_to_commit(const char *index_file, const char *prefix,

struct commit *current_head,

struct wt_status *s,

struct strbuf *author_ident)

{

struct stat statbuf;

struct strbuf committer_ident = STRBUF_INIT;

int commitable;

struct strbuf sb = STRBUF_INIT;

const char *hook_arg1 = NULL;

const char *hook_arg2 = NULL;

int clean_message_contents = (cleanup_mode != CLEANUP_NONE);

int old_display_comment_prefix;

/* This checks and barfs if author is badly specified */

determine_author_info(author_ident);

if (!no_verify && run_commit_hook(use_editor, index_file, "pre-commit", NULL))

return 0;

if (squash_message) {

/*

* Insert the proper subject line before other commit

* message options add their content.

*/

if (use_message && !strcmp(use_message, squash_message))

strbuf_addstr(&sb, "squash! ");

else {

struct pretty_print_context ctx = {0};

struct commit *c;

c = lookup_commit_reference_by_name(squash_message);

if (!c)

die(_("could not lookup commit %s"), squash_message);

ctx.output_encoding = get_commit_output_encoding();

format_commit_message(c, "squash! %s\n\n", &sb,

&ctx);

}

}

if (message.len) {

strbuf_addbuf(&sb, &message);

hook_arg1 = "message";

} else if (logfile && !strcmp(logfile, "-")) {

if (isatty(0))

fprintf(stderr, _("(reading log message from standard input)\n"));

if (strbuf_read(&sb, 0, 0) < 0)

die_errno(_("could not read log from standard input"));

hook_arg1 = "message";

} else if (logfile) {

if (strbuf_read_file(&sb, logfile, 0) < 0)

die_errno(_("could not read log file '%s'"),

logfile);

hook_arg1 = "message";

} else if (use_message) {

char *buffer;

buffer = strstr(use_message_buffer, "\n\n");

if (buffer)

strbuf_addstr(&sb, buffer + 2);

hook_arg1 = "commit";

hook_arg2 = use_message;

} else if (fixup_message) {

struct pretty_print_context ctx = {0};

struct commit *commit;

commit = lookup_commit_reference_by_name(fixup_message);

if (!commit)

die(_("could not lookup commit %s"), fixup_message);

ctx.output_encoding = get_commit_output_encoding();

format_commit_message(commit, "fixup! %s\n\n",

&sb, &ctx);

hook_arg1 = "message";

} else if (!stat(git_path("MERGE_MSG"), &statbuf)) {

if (strbuf_read_file(&sb, git_path("MERGE_MSG"), 0) < 0)

die_errno(_("could not read MERGE_MSG"));

hook_arg1 = "merge";

} else if (!stat(git_path("SQUASH_MSG"), &statbuf)) {

if (strbuf_read_file(&sb, git_path("SQUASH_MSG"), 0) < 0)

die_errno(_("could not read SQUASH_MSG"));

hook_arg1 = "squash";

} else if (template_file) {

if (strbuf_read_file(&sb, template_file, 0) < 0)

die_errno(_("could not read '%s'"), template_file);

hook_arg1 = "template";

clean_message_contents = 0;

}

/*

* The remaining cases don't modify the template message, but

* just set the argument(s) to the prepare-commit-msg hook.

*/

else if (whence == FROM_MERGE)

hook_arg1 = "merge";

else if (whence == FROM_CHERRY_PICK) {

hook_arg1 = "commit";

hook_arg2 = "CHERRY_PICK_HEAD";

}

if (squash_message) {

/*

* If squash_commit was used for the commit subject,

* then we're possibly hijacking other commit log options.

* Reset the hook args to tell the real story.

*/

hook_arg1 = "message";

hook_arg2 = "";

}

s->fp = fopen(git_path(commit_editmsg), "w");

if (s->fp == NULL)

die_errno(_("could not open '%s'"), git_path(commit_editmsg));

/* Ignore status.displayCommentPrefix: we do need comments in COMMIT_EDITMSG. */

old_display_comment_prefix = s->display_comment_prefix;

s->display_comment_prefix = 1;

/*

* Most hints are counter-productive when the commit has

* already started.

*/

s->hints = 0;

if (clean_message_contents)

stripspace(&sb, 0);

if (signoff)

append_signoff(&sb, ignore_non_trailer(&sb), 0);

if (fwrite(sb.buf, 1, sb.len, s->fp) < sb.len)

die_errno(_("could not write commit template"));

if (auto_comment_line_char)

adjust_comment_line_char(&sb);

strbuf_release(&sb);

/* This checks if committer ident is explicitly given */

strbuf_addstr(&committer_ident, git_committer_info(IDENT_STRICT));

if (use_editor && include_status) {

int ident_shown = 0;

int saved_color_setting;

struct ident_split ci, ai;

if (whence != FROM_COMMIT) {

if (cleanup_mode == CLEANUP_SCISSORS)

wt_status_add_cut_line(s->fp);

status_printf_ln(s, GIT_COLOR_NORMAL,

whence == FROM_MERGE

? _("\n"

"It looks like you may be committing a merge.\n"

"If this is not correct, please remove the file\n"

" %s\n"

"and try again.\n")

: _("\n"

"It looks like you may be committing a cherry-pick.\n"

"If this is not correct, please remove the file\n"

" %s\n"

"and try again.\n"),

git_path(whence == FROM_MERGE

? "MERGE_HEAD"

: "CHERRY_PICK_HEAD"));

}

fprintf(s->fp, "\n");

if (cleanup_mode == CLEANUP_ALL)

status_printf(s, GIT_COLOR_NORMAL,

_("Please enter the commit message for your changes."

" Lines starting\nwith '%c' will be ignored, and an empty"

" message aborts the commit.\n"), comment_line_char);

else if (cleanup_mode == CLEANUP_SCISSORS && whence == FROM_COMMIT)

wt_status_add_cut_line(s->fp);

else /* CLEANUP_SPACE, that is. */

status_printf(s, GIT_COLOR_NORMAL,

_("Please enter the commit message for your changes."

" Lines starting\n"

"with '%c' will be kept; you may remove them"

" yourself if you want to.\n"

"An empty message aborts the commit.\n"), comment_line_char);

if (only_include_assumed)

status_printf_ln(s, GIT_COLOR_NORMAL,

"%s", only_include_assumed);

/*

* These should never fail because they come from our own

* fmt_ident. They may fail the sane_ident test, but we know

* that the name and mail pointers will at least be valid,

* which is enough for our tests and printing here.

*/

assert_split_ident(&ai, author_ident);

assert_split_ident(&ci, &committer_ident);

if (ident_cmp(&ai, &ci))

status_printf_ln(s, GIT_COLOR_NORMAL,

_("%s"

"Author: %.*s <%.*s>"),

ident_shown++ ? "" : "\n",

(int)(ai.name_end - ai.name_begin), ai.name_begin,

(int)(ai.mail_end - ai.mail_begin), ai.mail_begin);

if (author_date_is_interesting())

status_printf_ln(s, GIT_COLOR_NORMAL,

_("%s"

"Date: %s"),

ident_shown++ ? "" : "\n",

show_ident_date(&ai, DATE_NORMAL));

if (!committer_ident_sufficiently_given())

status_printf_ln(s, GIT_COLOR_NORMAL,

_("%s"

"Committer: %.*s <%.*s>"),

ident_shown++ ? "" : "\n",

(int)(ci.name_end - ci.name_begin), ci.name_begin,

(int)(ci.mail_end - ci.mail_begin), ci.mail_begin);

if (ident_shown)

status_printf_ln(s, GIT_COLOR_NORMAL, "%s", "");

saved_color_setting = s->use_color;

s->use_color = 0;

commitable = run_status(s->fp, index_file, prefix, 1, s);

s->use_color = saved_color_setting;

} else {

unsigned char sha1[20];

const char *parent = "HEAD";

if (!active_nr && read_cache() < 0)

die(_("Cannot read index"));

if (amend)

parent = "HEAD^1";

if (get_sha1(parent, sha1))

commitable = !!active_nr;

else {

/*

* Unless the user did explicitly request a submodule

* ignore mode by passing a command line option we do

* not ignore any changed submodule SHA-1s when

* comparing index and parent, no matter what is

* configured. Otherwise we won't commit any

* submodules which were manually staged, which would

* be really confusing.

*/

int diff_flags = DIFF_OPT_OVERRIDE_SUBMODULE_CONFIG;

if (ignore_submodule_arg &&

!strcmp(ignore_submodule_arg, "all"))

diff_flags |= DIFF_OPT_IGNORE_SUBMODULES;

commitable = index_differs_from(parent, diff_flags);

}

}

strbuf_release(&committer_ident);

fclose(s->fp);

/*

* Reject an attempt to record a non-merge empty commit without

* explicit --allow-empty. In the cherry-pick case, it may be

* empty due to conflict resolution, which the user should okay.

*/

if (!commitable && whence != FROM_MERGE && !allow_empty &&

!(amend && is_a_merge(current_head))) {

s->display_comment_prefix = old_display_comment_prefix;

run_status(stdout, index_file, prefix, 0, s);

if (amend)

fputs(_(empty_amend_advice), stderr);

else if (whence == FROM_CHERRY_PICK) {

fputs(_(empty_cherry_pick_advice), stderr);

if (!sequencer_in_use)

fputs(_(empty_cherry_pick_advice_single), stderr);

else

fputs(_(empty_cherry_pick_advice_multi), stderr);

}

return 0;

}

/*

* Re-read the index as pre-commit hook could have updated it,

* and write it out as a tree. We must do this before we invoke

* the editor and after we invoke run_status above.

*/

discard_cache();

read_cache_from(index_file);

if (update_main_cache_tree(0)) {

error(_("Error building trees"));

return 0;

}

if (run_commit_hook(use_editor, index_file, "prepare-commit-msg",

git_path(commit_editmsg), hook_arg1, hook_arg2, NULL))

return 0;

if (use_editor) {

char index[PATH_MAX];

const char *env[2] = { NULL };

env[0] = index;

snprintf(index, sizeof(index), "GIT_INDEX_FILE=%s", index_file);

if (launch_editor(git_path(commit_editmsg), NULL, env)) {

fprintf(stderr,

_("Please supply the message using either -m or -F option.\n"));

exit(1);

}

}

if (!no_verify &&

run_commit_hook(use_editor, index_file, "commit-msg", git_path(commit_editmsg), NULL)) {

return 0;

}

return 1;

}

static int rest_is_empty(struct strbuf *sb, int start)

{

int i, eol;

const char *nl;

/* Check if the rest is just whitespace and Signed-of-by's. */

for (i = start; i < sb->len; i++) {

nl = memchr(sb->buf + i, '\n', sb->len - i);

if (nl)

eol = nl - sb->buf;

else

eol = sb->len;

if (strlen(sign_off_header) <= eol - i &&

starts_with(sb->buf + i, sign_off_header)) {

i = eol;

continue;

}

while (i < eol)

if (!isspace(sb->buf[i++]))

return 0;

}

return 1;

}

/*

* Find out if the message in the strbuf contains only whitespace and

* Signed-off-by lines.

*/

static int message_is_empty(struct strbuf *sb)

{

if (cleanup_mode == CLEANUP_NONE && sb->len)

return 0;

return rest_is_empty(sb, 0);