2007-11-08 16:59:00 +00:00
|
|
|
/*
|
|
|
|
* 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 "cache-tree.h"
|
2008-02-18 07:26:03 +00:00
|
|
|
#include "color.h"
|
2007-11-18 09:52:55 +00:00
|
|
|
#include "dir.h"
|
2007-11-08 16:59:00 +00:00
|
|
|
#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"
|
2008-07-21 18:03:49 +00:00
|
|
|
#include "string-list.h"
|
2008-07-09 12:58:57 +00:00
|
|
|
#include "rerere.h"
|
2008-01-13 08:30:56 +00:00
|
|
|
#include "unpack-trees.h"
|
2009-08-08 06:31:57 +00:00
|
|
|
#include "quote.h"
|
2007-11-08 16:59:00 +00:00
|
|
|
|
|
|
|
static const char * const builtin_commit_usage[] = {
|
2008-07-13 13:36:15 +00:00
|
|
|
"git commit [options] [--] <filepattern>...",
|
2007-11-08 16:59:00 +00:00
|
|
|
NULL
|
|
|
|
};
|
|
|
|
|
2007-12-03 05:02:09 +00:00
|
|
|
static const char * const builtin_status_usage[] = {
|
2008-07-13 13:36:15 +00:00
|
|
|
"git status [options] [--] <filepattern>...",
|
2007-12-03 05:02:09 +00:00
|
|
|
NULL
|
|
|
|
};
|
|
|
|
|
commit: show interesting ident information in summary
There are a few cases of user identity information that we consider
interesting:
(1) When the author and committer identities do not match.
(2) When the committer identity was picked automatically from the
username, hostname and GECOS information.
In these cases, we already show the information in the commit
message template. However, users do not always see that template
because they might use "-m" or "-F". With this patch, we show these
interesting cases after the commit, along with the subject and
change summary. The new output looks like:
$ git commit \
-m "federalist papers" \
--author='Publius <alexander@hamilton.com>'
[master 3d226a7] federalist papers
Author: Publius <alexander@hamilton.com>
1 files changed, 1 insertions(+), 0 deletions(-)
for case (1), and:
$ git config --global --unset user.name
$ git config --global --unset user.email
$ git commit -m foo
[master 7c2a927] foo
Committer: Jeff King <peff@c-71-185-130-222.hsd1.va.comcast.net>
Your name and email address were configured automatically based
on your username and hostname. Please check that they are accurate.
You can suppress this message by setting them explicitly:
git config --global user.name Your Name
git config --global user.email you@example.com
If the identity used for this commit is wrong, you can fix it with:
git commit --amend --author='Your Name <you@example.com>'
1 files changed, 1 insertions(+), 0 deletions(-)
for case (2).
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2010-01-13 17:39:51 +00:00
|
|
|
static const char implicit_ident_advice[] =
|
|
|
|
"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"
|
2010-02-24 14:18:25 +00:00
|
|
|
" git config --global user.name \"Your Name\"\n"
|
commit: show interesting ident information in summary
There are a few cases of user identity information that we consider
interesting:
(1) When the author and committer identities do not match.
(2) When the committer identity was picked automatically from the
username, hostname and GECOS information.
In these cases, we already show the information in the commit
message template. However, users do not always see that template
because they might use "-m" or "-F". With this patch, we show these
interesting cases after the commit, along with the subject and
change summary. The new output looks like:
$ git commit \
-m "federalist papers" \
--author='Publius <alexander@hamilton.com>'
[master 3d226a7] federalist papers
Author: Publius <alexander@hamilton.com>
1 files changed, 1 insertions(+), 0 deletions(-)
for case (1), and:
$ git config --global --unset user.name
$ git config --global --unset user.email
$ git commit -m foo
[master 7c2a927] foo
Committer: Jeff King <peff@c-71-185-130-222.hsd1.va.comcast.net>
Your name and email address were configured automatically based
on your username and hostname. Please check that they are accurate.
You can suppress this message by setting them explicitly:
git config --global user.name Your Name
git config --global user.email you@example.com
If the identity used for this commit is wrong, you can fix it with:
git commit --amend --author='Your Name <you@example.com>'
1 files changed, 1 insertions(+), 0 deletions(-)
for case (2).
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2010-01-13 17:39:51 +00:00
|
|
|
" git config --global user.email you@example.com\n"
|
|
|
|
"\n"
|
|
|
|
"If the identity used for this commit is wrong, you can fix it with:\n"
|
|
|
|
"\n"
|
|
|
|
" git commit --amend --author='Your Name <you@example.com>'\n";
|
|
|
|
|
2009-12-12 07:45:24 +00:00
|
|
|
static unsigned char head_sha1[20];
|
commit: show interesting ident information in summary
There are a few cases of user identity information that we consider
interesting:
(1) When the author and committer identities do not match.
(2) When the committer identity was picked automatically from the
username, hostname and GECOS information.
In these cases, we already show the information in the commit
message template. However, users do not always see that template
because they might use "-m" or "-F". With this patch, we show these
interesting cases after the commit, along with the subject and
change summary. The new output looks like:
$ git commit \
-m "federalist papers" \
--author='Publius <alexander@hamilton.com>'
[master 3d226a7] federalist papers
Author: Publius <alexander@hamilton.com>
1 files changed, 1 insertions(+), 0 deletions(-)
for case (1), and:
$ git config --global --unset user.name
$ git config --global --unset user.email
$ git commit -m foo
[master 7c2a927] foo
Committer: Jeff King <peff@c-71-185-130-222.hsd1.va.comcast.net>
Your name and email address were configured automatically based
on your username and hostname. Please check that they are accurate.
You can suppress this message by setting them explicitly:
git config --global user.name Your Name
git config --global user.email you@example.com
If the identity used for this commit is wrong, you can fix it with:
git commit --amend --author='Your Name <you@example.com>'
1 files changed, 1 insertions(+), 0 deletions(-)
for case (2).
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2010-01-13 17:39:51 +00:00
|
|
|
|
2007-11-08 16:59:00 +00:00
|
|
|
static char *use_message_buffer;
|
|
|
|
static const char commit_editmsg[] = "COMMIT_EDITMSG";
|
2007-11-18 09:52:55 +00:00
|
|
|
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;
|
2007-11-08 16:59:00 +00:00
|
|
|
|
2008-08-06 18:43:47 +00:00
|
|
|
static const char *logfile, *force_author;
|
2008-07-05 05:24:40 +00:00
|
|
|
static const char *template_file;
|
2007-11-08 16:59:00 +00:00
|
|
|
static char *edit_message, *use_message;
|
2008-05-04 16:04:50 +00:00
|
|
|
static char *author_name, *author_email, *author_date;
|
2007-11-08 16:59:00 +00:00
|
|
|
static int all, edit_flag, also, interactive, only, amend, signoff;
|
2009-11-04 03:20:11 +00:00
|
|
|
static int quiet, verbose, no_verify, allow_empty, dry_run, renew_authorship;
|
2010-03-12 17:04:28 +00:00
|
|
|
static int no_post_rewrite;
|
2009-12-02 22:16:18 +00:00
|
|
|
static char *untracked_files_arg, *force_date;
|
2007-12-22 18:46:24 +00:00
|
|
|
/*
|
|
|
|
* 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_ALL,
|
|
|
|
} cleanup_mode;
|
|
|
|
static char *cleanup_arg;
|
2007-11-08 16:59:00 +00:00
|
|
|
|
2009-12-07 22:45:27 +00:00
|
|
|
static int use_editor = 1, initial_commit, in_merge, include_status = 1;
|
2008-07-22 20:40:41 +00:00
|
|
|
static const char *only_include_assumed;
|
|
|
|
static struct strbuf message;
|
2007-11-11 17:36:39 +00:00
|
|
|
|
2009-09-05 08:59:56 +00:00
|
|
|
static int null_termination;
|
|
|
|
static enum {
|
|
|
|
STATUS_FORMAT_LONG,
|
|
|
|
STATUS_FORMAT_SHORT,
|
|
|
|
STATUS_FORMAT_PORCELAIN,
|
|
|
|
} status_format = STATUS_FORMAT_LONG;
|
|
|
|
|
2007-11-11 17:36:39 +00:00
|
|
|
static int opt_parse_m(const struct option *opt, const char *arg, int unset)
|
|
|
|
{
|
|
|
|
struct strbuf *buf = opt->value;
|
|
|
|
if (unset)
|
|
|
|
strbuf_setlen(buf, 0);
|
|
|
|
else {
|
|
|
|
strbuf_addstr(buf, arg);
|
2008-07-22 20:40:41 +00:00
|
|
|
strbuf_addstr(buf, "\n\n");
|
2007-11-11 17:36:39 +00:00
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
2007-11-08 16:59:00 +00:00
|
|
|
|
|
|
|
static struct option builtin_commit_options[] = {
|
|
|
|
OPT__QUIET(&quiet),
|
|
|
|
OPT__VERBOSE(&verbose),
|
|
|
|
|
2009-12-29 21:54:49 +00:00
|
|
|
OPT_GROUP("Commit message options"),
|
2009-05-23 18:53:13 +00:00
|
|
|
OPT_FILENAME('F', "file", &logfile, "read log from file"),
|
2007-11-08 16:59:00 +00:00
|
|
|
OPT_STRING(0, "author", &force_author, "AUTHOR", "override author for commit"),
|
2009-12-02 22:16:18 +00:00
|
|
|
OPT_STRING(0, "date", &force_date, "DATE", "override date for commit"),
|
2007-11-11 17:36:39 +00:00
|
|
|
OPT_CALLBACK('m', "message", &message, "MESSAGE", "specify commit message", opt_parse_m),
|
2009-11-04 03:20:11 +00:00
|
|
|
OPT_STRING('c', "reedit-message", &edit_message, "COMMIT", "reuse and edit message from specified commit"),
|
2007-11-08 16:59:00 +00:00
|
|
|
OPT_STRING('C', "reuse-message", &use_message, "COMMIT", "reuse message from specified commit"),
|
2009-11-04 03:20:11 +00:00
|
|
|
OPT_BOOLEAN(0, "reset-author", &renew_authorship, "the commit is authored by me now (used with -C-c/--amend)"),
|
2008-04-27 00:43:20 +00:00
|
|
|
OPT_BOOLEAN('s', "signoff", &signoff, "add Signed-off-by:"),
|
2009-05-23 18:53:13 +00:00
|
|
|
OPT_FILENAME('t', "template", &template_file, "use specified template file"),
|
2007-11-08 16:59:00 +00:00
|
|
|
OPT_BOOLEAN('e', "edit", &edit_flag, "force edit of commit"),
|
2009-12-29 21:54:49 +00:00
|
|
|
OPT_STRING(0, "cleanup", &cleanup_arg, "default", "how to strip spaces and #comments from message"),
|
2009-12-07 22:45:27 +00:00
|
|
|
OPT_BOOLEAN(0, "status", &include_status, "include status in commit message template"),
|
2009-12-29 21:54:49 +00:00
|
|
|
/* end commit message options */
|
2007-11-08 16:59:00 +00:00
|
|
|
|
|
|
|
OPT_GROUP("Commit contents options"),
|
|
|
|
OPT_BOOLEAN('a', "all", &all, "commit all changed files"),
|
|
|
|
OPT_BOOLEAN('i', "include", &also, "add specified files to index for commit"),
|
|
|
|
OPT_BOOLEAN(0, "interactive", &interactive, "interactively add files"),
|
2008-04-10 11:33:09 +00:00
|
|
|
OPT_BOOLEAN('o', "only", &only, "commit only specified files"),
|
2007-11-08 16:59:00 +00:00
|
|
|
OPT_BOOLEAN('n', "no-verify", &no_verify, "bypass pre-commit hook"),
|
2009-08-08 06:03:36 +00:00
|
|
|
OPT_BOOLEAN(0, "dry-run", &dry_run, "show what would be committed"),
|
2009-09-05 08:59:56 +00:00
|
|
|
OPT_SET_INT(0, "short", &status_format, "show status concisely",
|
|
|
|
STATUS_FORMAT_SHORT),
|
|
|
|
OPT_SET_INT(0, "porcelain", &status_format,
|
|
|
|
"show porcelain output format", STATUS_FORMAT_PORCELAIN),
|
|
|
|
OPT_BOOLEAN('z', "null", &null_termination,
|
|
|
|
"terminate entries with NUL"),
|
2007-11-08 16:59:00 +00:00
|
|
|
OPT_BOOLEAN(0, "amend", &amend, "amend previous commit"),
|
2010-03-12 17:04:28 +00:00
|
|
|
OPT_BOOLEAN(0, "no-post-rewrite", &no_post_rewrite, "bypass post-rewrite hook"),
|
2008-06-05 12:22:56 +00:00
|
|
|
{ OPTION_STRING, 'u', "untracked-files", &untracked_files_arg, "mode", "show untracked files, optional modes: all, normal, no. (Default: all)", PARSE_OPT_OPTARG, NULL, (intptr_t)"all" },
|
2007-12-03 08:03:10 +00:00
|
|
|
OPT_BOOLEAN(0, "allow-empty", &allow_empty, "ok to record an empty change"),
|
2009-12-29 21:54:49 +00:00
|
|
|
/* end commit contents options */
|
2007-11-08 16:59:00 +00:00
|
|
|
|
|
|
|
OPT_END()
|
|
|
|
};
|
|
|
|
|
2007-11-18 09:52:55 +00:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-01-23 17:21:22 +00:00
|
|
|
static int commit_index_files(void)
|
2007-11-18 09:52:55 +00:00
|
|
|
{
|
2008-01-23 17:21:22 +00:00
|
|
|
int err = 0;
|
|
|
|
|
2007-11-18 09:52:55 +00:00
|
|
|
switch (commit_style) {
|
|
|
|
case COMMIT_AS_IS:
|
|
|
|
break; /* nothing to do */
|
|
|
|
case COMMIT_NORMAL:
|
2008-01-23 17:21:22 +00:00
|
|
|
err = commit_lock_file(&index_lock);
|
2007-11-18 09:52:55 +00:00
|
|
|
break;
|
|
|
|
case COMMIT_PARTIAL:
|
2008-01-23 17:21:22 +00:00
|
|
|
err = commit_lock_file(&index_lock);
|
2007-11-18 09:52:55 +00:00
|
|
|
rollback_lock_file(&false_lock);
|
|
|
|
break;
|
|
|
|
}
|
2008-01-23 17:21:22 +00:00
|
|
|
|
|
|
|
return err;
|
2007-11-18 09:52:55 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 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.
|
|
|
|
*/
|
2008-07-21 18:03:49 +00:00
|
|
|
static int list_paths(struct string_list *list, const char *with_tree,
|
2007-11-18 09:52:55 +00:00
|
|
|
const char *prefix, const char **pattern)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
char *m;
|
|
|
|
|
|
|
|
for (i = 0; pattern[i]; i++)
|
|
|
|
;
|
|
|
|
m = xcalloc(1, i);
|
|
|
|
|
|
|
|
if (with_tree)
|
|
|
|
overlay_tree_on_cache(with_tree, prefix);
|
|
|
|
|
|
|
|
for (i = 0; i < active_nr; i++) {
|
|
|
|
struct cache_entry *ce = active_cache[i];
|
2009-12-14 11:43:59 +00:00
|
|
|
struct string_list_item *item;
|
|
|
|
|
2008-01-15 00:03:17 +00:00
|
|
|
if (ce->ce_flags & CE_UPDATE)
|
2008-01-14 21:54:24 +00:00
|
|
|
continue;
|
2009-01-14 14:54:35 +00:00
|
|
|
if (!match_pathspec(pattern, ce->name, ce_namelen(ce), 0, m))
|
2007-11-18 09:52:55 +00:00
|
|
|
continue;
|
2009-12-14 11:43:59 +00:00
|
|
|
item = string_list_insert(ce->name, list);
|
|
|
|
if (ce_skip_worktree(ce))
|
|
|
|
item->util = item; /* better a valid pointer than a fake one */
|
2007-11-18 09:52:55 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return report_path_error(m, pattern, prefix ? strlen(prefix) : 0);
|
|
|
|
}
|
|
|
|
|
2008-07-21 18:03:49 +00:00
|
|
|
static void add_remove_files(struct string_list *list)
|
2007-11-18 09:52:55 +00:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
for (i = 0; i < list->nr; i++) {
|
2008-05-09 16:11:43 +00:00
|
|
|
struct stat st;
|
2008-07-21 18:03:49 +00:00
|
|
|
struct string_list_item *p = &(list->items[i]);
|
2008-05-09 16:11:43 +00:00
|
|
|
|
2009-12-14 11:43:59 +00:00
|
|
|
/* p->util is skip-worktree */
|
|
|
|
if (p->util)
|
2009-08-20 13:46:58 +00:00
|
|
|
continue;
|
2008-05-09 16:11:43 +00:00
|
|
|
|
2008-07-21 18:03:49 +00:00
|
|
|
if (!lstat(p->string, &st)) {
|
|
|
|
if (add_to_cache(p->string, &st, 0))
|
2008-05-12 17:57:45 +00:00
|
|
|
die("updating files failed");
|
|
|
|
} else
|
2008-07-21 18:03:49 +00:00
|
|
|
remove_file_from_cache(p->string);
|
2007-11-18 09:52:55 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-01-13 08:30:56 +00:00
|
|
|
static void create_base_index(void)
|
|
|
|
{
|
|
|
|
struct tree *tree;
|
|
|
|
struct unpack_trees_options opts;
|
|
|
|
struct tree_desc t;
|
|
|
|
|
|
|
|
if (initial_commit) {
|
|
|
|
discard_cache();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
memset(&opts, 0, sizeof(opts));
|
|
|
|
opts.head_idx = 1;
|
|
|
|
opts.index_only = 1;
|
|
|
|
opts.merge = 1;
|
2008-03-07 02:12:28 +00:00
|
|
|
opts.src_index = &the_index;
|
|
|
|
opts.dst_index = &the_index;
|
2008-01-13 08:30:56 +00:00
|
|
|
|
|
|
|
opts.fn = oneway_merge;
|
|
|
|
tree = parse_tree_indirect(head_sha1);
|
|
|
|
if (!tree)
|
|
|
|
die("failed to unpack HEAD tree object");
|
|
|
|
parse_tree(tree);
|
|
|
|
init_tree_desc(&t, tree->buffer, tree->size);
|
2008-02-07 16:39:48 +00:00
|
|
|
if (unpack_trees(1, &t, &opts))
|
|
|
|
exit(128); /* We've already reported the error, finish dying */
|
2008-01-13 08:30:56 +00:00
|
|
|
}
|
|
|
|
|
Be more user-friendly when refusing to do something because of conflict.
Various commands refuse to run in the presence of conflicts (commit,
merge, pull, cherry-pick/revert). They all used to provide rough, and
inconsistant error messages.
A new variable advice.resolveconflict is introduced, and allows more
verbose messages, pointing the user to the appropriate solution.
For commit, the error message used to look like this:
$ git commit
foo.txt: needs merge
foo.txt: unmerged (c34a92682e0394bc0d6f4d4a67a8e2d32395c169)
foo.txt: unmerged (3afcd75de8de0bb5076942fcb17446be50451030)
foo.txt: unmerged (c9785d77b76dfe4fb038bf927ee518f6ae45ede4)
error: Error building trees
The "need merge" line is given by refresh_cache. We add the IN_PORCELAIN
option to make the output more consistant with the other porcelain
commands, and catch the error in return, to stop with a clean error
message. The next lines were displayed by a call to cache_tree_update(),
which is not reached anymore if we noticed the conflict.
The new output looks like:
U foo.txt
fatal: 'commit' is not possible because you have unmerged files.
Please, fix them up in the work tree, and then use 'git add/rm <file>' as
appropriate to mark resolution and make a commit, or use 'git commit -a'.
Pull is slightly modified to abort immediately if $GIT_DIR/MERGE_HEAD
exists instead of waiting for merge to complain.
The behavior of merge and the test-case are slightly modified to reflect
the usual flow: start with conflicts, fix them, and afterwards get rid of
MERGE_HEAD, with different error messages at each stage.
Signed-off-by: Matthieu Moy <Matthieu.Moy@imag.fr>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2010-01-12 09:54:44 +00:00
|
|
|
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");
|
|
|
|
}
|
|
|
|
|
2009-08-05 06:49:33 +00:00
|
|
|
static char *prepare_index(int argc, const char **argv, const char *prefix, int is_status)
|
2007-11-08 16:59:00 +00:00
|
|
|
{
|
|
|
|
int fd;
|
2008-07-21 18:03:49 +00:00
|
|
|
struct string_list partial;
|
2007-11-18 09:52:55 +00:00
|
|
|
const char **pathspec = NULL;
|
2009-08-05 06:49:33 +00:00
|
|
|
int refresh_flags = REFRESH_QUIET;
|
2007-11-08 16:59:00 +00:00
|
|
|
|
2009-08-05 06:49:33 +00:00
|
|
|
if (is_status)
|
|
|
|
refresh_flags |= REFRESH_UNMERGED;
|
2007-11-08 16:59:00 +00:00
|
|
|
if (interactive) {
|
2009-04-03 19:28:56 +00:00
|
|
|
if (interactive_add(argc, argv, prefix) != 0)
|
|
|
|
die("interactive add failed");
|
2008-11-14 00:36:30 +00:00
|
|
|
if (read_cache_preload(NULL) < 0)
|
2008-05-27 08:59:16 +00:00
|
|
|
die("index file corrupt");
|
2007-11-18 09:52:55 +00:00
|
|
|
commit_style = COMMIT_AS_IS;
|
2007-11-08 16:59:00 +00:00
|
|
|
return get_index_file();
|
|
|
|
}
|
|
|
|
|
2007-11-25 16:46:29 +00:00
|
|
|
if (*argv)
|
|
|
|
pathspec = get_pathspec(prefix, argv);
|
2007-11-18 09:52:55 +00:00
|
|
|
|
2008-11-14 00:36:30 +00:00
|
|
|
if (read_cache_preload(pathspec) < 0)
|
|
|
|
die("index file corrupt");
|
|
|
|
|
2007-11-18 09:52:55 +00:00
|
|
|
/*
|
|
|
|
* 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 && *pathspec)) {
|
|
|
|
int fd = hold_locked_index(&index_lock, 1);
|
2008-05-12 17:58:10 +00:00
|
|
|
add_files_to_cache(also ? prefix : NULL, pathspec, 0);
|
Be more user-friendly when refusing to do something because of conflict.
Various commands refuse to run in the presence of conflicts (commit,
merge, pull, cherry-pick/revert). They all used to provide rough, and
inconsistant error messages.
A new variable advice.resolveconflict is introduced, and allows more
verbose messages, pointing the user to the appropriate solution.
For commit, the error message used to look like this:
$ git commit
foo.txt: needs merge
foo.txt: unmerged (c34a92682e0394bc0d6f4d4a67a8e2d32395c169)
foo.txt: unmerged (3afcd75de8de0bb5076942fcb17446be50451030)
foo.txt: unmerged (c9785d77b76dfe4fb038bf927ee518f6ae45ede4)
error: Error building trees
The "need merge" line is given by refresh_cache. We add the IN_PORCELAIN
option to make the output more consistant with the other porcelain
commands, and catch the error in return, to stop with a clean error
message. The next lines were displayed by a call to cache_tree_update(),
which is not reached anymore if we noticed the conflict.
The new output looks like:
U foo.txt
fatal: 'commit' is not possible because you have unmerged files.
Please, fix them up in the work tree, and then use 'git add/rm <file>' as
appropriate to mark resolution and make a commit, or use 'git commit -a'.
Pull is slightly modified to abort immediately if $GIT_DIR/MERGE_HEAD
exists instead of waiting for merge to complain.
The behavior of merge and the test-case are slightly modified to reflect
the usual flow: start with conflicts, fix them, and afterwards get rid of
MERGE_HEAD, with different error messages at each stage.
Signed-off-by: Matthieu Moy <Matthieu.Moy@imag.fr>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2010-01-12 09:54:44 +00:00
|
|
|
refresh_cache_or_die(refresh_flags);
|
2008-01-16 19:12:46 +00:00
|
|
|
if (write_cache(fd, active_cache, active_nr) ||
|
|
|
|
close_lock_file(&index_lock))
|
2007-11-08 16:59:00 +00:00
|
|
|
die("unable to write new_index file");
|
2007-11-18 09:52:55 +00:00
|
|
|
commit_style = COMMIT_NORMAL;
|
|
|
|
return index_lock.filename;
|
2007-11-08 16:59:00 +00:00
|
|
|
}
|
|
|
|
|
2007-11-18 09:52:55 +00:00
|
|
|
/*
|
|
|
|
* As-is commit.
|
|
|
|
*
|
|
|
|
* (1) return the name of the real index file.
|
|
|
|
*
|
|
|
|
* The caller should run hooks on the real index, and run
|
|
|
|
* hooks on the real index, and create commit from the_index.
|
|
|
|
* We still need to refresh the index here.
|
|
|
|
*/
|
|
|
|
if (!pathspec || !*pathspec) {
|
|
|
|
fd = hold_locked_index(&index_lock, 1);
|
Be more user-friendly when refusing to do something because of conflict.
Various commands refuse to run in the presence of conflicts (commit,
merge, pull, cherry-pick/revert). They all used to provide rough, and
inconsistant error messages.
A new variable advice.resolveconflict is introduced, and allows more
verbose messages, pointing the user to the appropriate solution.
For commit, the error message used to look like this:
$ git commit
foo.txt: needs merge
foo.txt: unmerged (c34a92682e0394bc0d6f4d4a67a8e2d32395c169)
foo.txt: unmerged (3afcd75de8de0bb5076942fcb17446be50451030)
foo.txt: unmerged (c9785d77b76dfe4fb038bf927ee518f6ae45ede4)
error: Error building trees
The "need merge" line is given by refresh_cache. We add the IN_PORCELAIN
option to make the output more consistant with the other porcelain
commands, and catch the error in return, to stop with a clean error
message. The next lines were displayed by a call to cache_tree_update(),
which is not reached anymore if we noticed the conflict.
The new output looks like:
U foo.txt
fatal: 'commit' is not possible because you have unmerged files.
Please, fix them up in the work tree, and then use 'git add/rm <file>' as
appropriate to mark resolution and make a commit, or use 'git commit -a'.
Pull is slightly modified to abort immediately if $GIT_DIR/MERGE_HEAD
exists instead of waiting for merge to complain.
The behavior of merge and the test-case are slightly modified to reflect
the usual flow: start with conflicts, fix them, and afterwards get rid of
MERGE_HEAD, with different error messages at each stage.
Signed-off-by: Matthieu Moy <Matthieu.Moy@imag.fr>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2010-01-12 09:54:44 +00:00
|
|
|
refresh_cache_or_die(refresh_flags);
|
2007-11-18 09:52:55 +00:00
|
|
|
if (write_cache(fd, active_cache, active_nr) ||
|
2008-01-15 20:00:02 +00:00
|
|
|
commit_locked_index(&index_lock))
|
2007-11-18 09:52:55 +00:00
|
|
|
die("unable to write new_index file");
|
|
|
|
commit_style = COMMIT_AS_IS;
|
2007-11-08 16:59:00 +00:00
|
|
|
return get_index_file();
|
|
|
|
}
|
|
|
|
|
2007-11-18 09:52:55 +00:00
|
|
|
/*
|
|
|
|
* 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;
|
|
|
|
|
2009-12-12 07:45:24 +00:00
|
|
|
if (in_merge)
|
2007-11-18 09:52:55 +00:00
|
|
|
die("cannot do a partial commit during a merge.");
|
|
|
|
|
|
|
|
memset(&partial, 0, sizeof(partial));
|
2008-07-21 18:03:49 +00:00
|
|
|
partial.strdup_strings = 1;
|
2007-11-18 09:52:55 +00:00
|
|
|
if (list_paths(&partial, initial_commit ? NULL : "HEAD", prefix, pathspec))
|
|
|
|
exit(1);
|
|
|
|
|
|
|
|
discard_cache();
|
|
|
|
if (read_cache() < 0)
|
|
|
|
die("cannot read the index");
|
|
|
|
|
|
|
|
fd = hold_locked_index(&index_lock, 1);
|
|
|
|
add_remove_files(&partial);
|
2007-11-12 20:48:22 +00:00
|
|
|
refresh_cache(REFRESH_QUIET);
|
2008-01-16 19:12:46 +00:00
|
|
|
if (write_cache(fd, active_cache, active_nr) ||
|
|
|
|
close_lock_file(&index_lock))
|
2007-11-08 16:59:00 +00:00
|
|
|
die("unable to write new_index file");
|
|
|
|
|
2007-11-18 09:52:55 +00:00
|
|
|
fd = hold_lock_file_for_update(&false_lock,
|
2008-10-22 00:58:11 +00:00
|
|
|
git_path("next-index-%"PRIuMAX,
|
|
|
|
(uintmax_t) getpid()),
|
2008-10-17 22:44:39 +00:00
|
|
|
LOCK_DIE_ON_ERROR);
|
2008-01-13 08:30:56 +00:00
|
|
|
|
|
|
|
create_base_index();
|
2007-11-18 09:52:55 +00:00
|
|
|
add_remove_files(&partial);
|
2007-11-09 16:40:27 +00:00
|
|
|
refresh_cache(REFRESH_QUIET);
|
2007-11-08 16:59:00 +00:00
|
|
|
|
2008-01-16 19:12:46 +00:00
|
|
|
if (write_cache(fd, active_cache, active_nr) ||
|
|
|
|
close_lock_file(&false_lock))
|
2007-11-18 09:52:55 +00:00
|
|
|
die("unable to write temporary index file");
|
2008-02-14 17:18:23 +00:00
|
|
|
|
|
|
|
discard_cache();
|
|
|
|
read_cache_from(false_lock.filename);
|
|
|
|
|
2007-11-18 09:52:55 +00:00
|
|
|
return false_lock.filename;
|
2007-11-08 16:59:00 +00:00
|
|
|
}
|
|
|
|
|
2009-08-10 04:59:30 +00:00
|
|
|
static int run_status(FILE *fp, const char *index_file, const char *prefix, int nowarn,
|
|
|
|
struct wt_status *s)
|
2007-11-08 16:59:00 +00:00
|
|
|
{
|
2009-08-08 06:31:57 +00:00
|
|
|
unsigned char sha1[20];
|
|
|
|
|
2009-08-10 04:59:30 +00:00
|
|
|
if (s->relative_paths)
|
|
|
|
s->prefix = prefix;
|
2007-11-08 16:59:00 +00:00
|
|
|
|
|
|
|
if (amend) {
|
2009-08-10 04:59:30 +00:00
|
|
|
s->amend = 1;
|
|
|
|
s->reference = "HEAD^1";
|
2007-11-08 16:59:00 +00:00
|
|
|
}
|
2009-08-10 04:59:30 +00:00
|
|
|
s->verbose = verbose;
|
|
|
|
s->index_file = index_file;
|
|
|
|
s->fp = fp;
|
|
|
|
s->nowarn = nowarn;
|
2009-08-08 06:31:57 +00:00
|
|
|
s->is_initial = get_sha1(s->reference, sha1) ? 1 : 0;
|
2007-11-08 16:59:00 +00:00
|
|
|
|
2009-08-08 06:31:57 +00:00
|
|
|
wt_status_collect(s);
|
2009-09-05 08:59:56 +00:00
|
|
|
|
|
|
|
switch (status_format) {
|
|
|
|
case STATUS_FORMAT_SHORT:
|
2009-12-05 15:04:37 +00:00
|
|
|
wt_shortstatus_print(s, null_termination);
|
2009-09-05 08:59:56 +00:00
|
|
|
break;
|
|
|
|
case STATUS_FORMAT_PORCELAIN:
|
2009-12-07 05:17:15 +00:00
|
|
|
wt_porcelain_print(s, null_termination);
|
2009-09-05 08:59:56 +00:00
|
|
|
break;
|
|
|
|
case STATUS_FORMAT_LONG:
|
|
|
|
wt_status_print(s);
|
|
|
|
break;
|
|
|
|
}
|
2007-11-08 16:59:00 +00:00
|
|
|
|
2009-08-10 04:59:30 +00:00
|
|
|
return s->commitable;
|
2007-11-08 16:59:00 +00:00
|
|
|
}
|
|
|
|
|
2008-02-05 10:01:46 +00:00
|
|
|
static int is_a_merge(const unsigned char *sha1)
|
|
|
|
{
|
|
|
|
struct commit *commit = lookup_commit(sha1);
|
|
|
|
if (!commit || parse_commit(commit))
|
|
|
|
die("could not parse HEAD commit");
|
|
|
|
return !!(commit->parents && commit->parents->next);
|
|
|
|
}
|
|
|
|
|
2007-11-08 16:59:00 +00:00
|
|
|
static const char sign_off_header[] = "Signed-off-by: ";
|
|
|
|
|
2008-05-04 16:04:50 +00:00
|
|
|
static void determine_author_info(void)
|
2008-05-04 16:04:49 +00:00
|
|
|
{
|
|
|
|
char *name, *email, *date;
|
|
|
|
|
|
|
|
name = getenv("GIT_AUTHOR_NAME");
|
|
|
|
email = getenv("GIT_AUTHOR_EMAIL");
|
|
|
|
date = getenv("GIT_AUTHOR_DATE");
|
|
|
|
|
2009-11-04 03:20:11 +00:00
|
|
|
if (use_message && !renew_authorship) {
|
2008-05-04 16:04:49 +00:00
|
|
|
const char *a, *lb, *rb, *eol;
|
|
|
|
|
|
|
|
a = strstr(use_message_buffer, "\nauthor ");
|
|
|
|
if (!a)
|
|
|
|
die("invalid commit: %s", use_message);
|
|
|
|
|
|
|
|
lb = strstr(a + 8, " <");
|
|
|
|
rb = strstr(a + 8, "> ");
|
|
|
|
eol = strchr(a + 8, '\n');
|
|
|
|
if (!lb || !rb || !eol)
|
|
|
|
die("invalid commit: %s", use_message);
|
|
|
|
|
|
|
|
name = xstrndup(a + 8, lb - (a + 8));
|
|
|
|
email = xstrndup(lb + 2, rb - (lb + 2));
|
|
|
|
date = xstrndup(rb + 2, eol - (rb + 2));
|
|
|
|
}
|
|
|
|
|
|
|
|
if (force_author) {
|
|
|
|
const char *lb = strstr(force_author, " <");
|
|
|
|
const char *rb = strchr(force_author, '>');
|
|
|
|
|
|
|
|
if (!lb || !rb)
|
|
|
|
die("malformed --author parameter");
|
|
|
|
name = xstrndup(force_author, lb - force_author);
|
|
|
|
email = xstrndup(lb + 2, rb - (lb + 2));
|
|
|
|
}
|
|
|
|
|
2009-12-02 22:16:18 +00:00
|
|
|
if (force_date)
|
|
|
|
date = force_date;
|
|
|
|
|
2008-05-04 16:04:50 +00:00
|
|
|
author_name = name;
|
|
|
|
author_email = email;
|
|
|
|
author_date = date;
|
2008-05-04 16:04:49 +00:00
|
|
|
}
|
|
|
|
|
2009-10-28 17:13:44 +00:00
|
|
|
static int ends_rfc2822_footer(struct strbuf *sb)
|
|
|
|
{
|
|
|
|
int ch;
|
|
|
|
int hit = 0;
|
|
|
|
int i, j, k;
|
|
|
|
int len = sb->len;
|
|
|
|
int first = 1;
|
|
|
|
const char *buf = sb->buf;
|
|
|
|
|
|
|
|
for (i = len - 1; i > 0; i--) {
|
|
|
|
if (hit && buf[i] == '\n')
|
|
|
|
break;
|
|
|
|
hit = (buf[i] == '\n');
|
|
|
|
}
|
|
|
|
|
|
|
|
while (i < len - 1 && buf[i] == '\n')
|
|
|
|
i++;
|
|
|
|
|
|
|
|
for (; i < len; i = k) {
|
|
|
|
for (k = i; k < len && buf[k] != '\n'; k++)
|
|
|
|
; /* do nothing */
|
|
|
|
k++;
|
|
|
|
|
|
|
|
if ((buf[k] == ' ' || buf[k] == '\t') && !first)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
first = 0;
|
|
|
|
|
|
|
|
for (j = 0; i + j < len; j++) {
|
|
|
|
ch = buf[i + j];
|
|
|
|
if (ch == ':')
|
|
|
|
break;
|
|
|
|
if (isalnum(ch) ||
|
|
|
|
(ch == '-'))
|
|
|
|
continue;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2009-08-10 04:59:30 +00:00
|
|
|
static int prepare_to_commit(const char *index_file, const char *prefix,
|
|
|
|
struct wt_status *s)
|
2007-11-08 16:59:00 +00:00
|
|
|
{
|
|
|
|
struct stat statbuf;
|
2007-11-18 20:01:38 +00:00
|
|
|
int commitable, saved_color_setting;
|
2008-10-09 19:12:12 +00:00
|
|
|
struct strbuf sb = STRBUF_INIT;
|
2007-11-08 16:59:00 +00:00
|
|
|
char *buffer;
|
|
|
|
FILE *fp;
|
2008-02-05 07:04:18 +00:00
|
|
|
const char *hook_arg1 = NULL;
|
|
|
|
const char *hook_arg2 = NULL;
|
2008-05-04 16:04:51 +00:00
|
|
|
int ident_shown = 0;
|
2007-11-08 16:59:00 +00:00
|
|
|
|
2008-02-05 10:01:46 +00:00
|
|
|
if (!no_verify && run_hook(index_file, "pre-commit", NULL))
|
|
|
|
return 0;
|
2007-11-08 16:59:00 +00:00
|
|
|
|
2007-11-11 17:36:39 +00:00
|
|
|
if (message.len) {
|
|
|
|
strbuf_addbuf(&sb, &message);
|
2008-02-05 07:04:18 +00:00
|
|
|
hook_arg1 = "message";
|
2007-11-08 16:59:00 +00:00
|
|
|
} else if (logfile && !strcmp(logfile, "-")) {
|
|
|
|
if (isatty(0))
|
|
|
|
fprintf(stderr, "(reading log message from standard input)\n");
|
|
|
|
if (strbuf_read(&sb, 0, 0) < 0)
|
2009-06-27 15:58:47 +00:00
|
|
|
die_errno("could not read log from standard input");
|
2008-02-05 07:04:18 +00:00
|
|
|
hook_arg1 = "message";
|
2007-11-08 16:59:00 +00:00
|
|
|
} else if (logfile) {
|
|
|
|
if (strbuf_read_file(&sb, logfile, 0) < 0)
|
2009-06-27 15:58:46 +00:00
|
|
|
die_errno("could not read log file '%s'",
|
|
|
|
logfile);
|
2008-02-05 07:04:18 +00:00
|
|
|
hook_arg1 = "message";
|
2007-11-08 16:59:00 +00:00
|
|
|
} else if (use_message) {
|
|
|
|
buffer = strstr(use_message_buffer, "\n\n");
|
|
|
|
if (!buffer || buffer[2] == '\0')
|
|
|
|
die("commit has empty message");
|
|
|
|
strbuf_add(&sb, buffer + 2, strlen(buffer + 2));
|
2008-02-05 07:04:18 +00:00
|
|
|
hook_arg1 = "commit";
|
|
|
|
hook_arg2 = use_message;
|
2007-11-08 16:59:00 +00:00
|
|
|
} else if (!stat(git_path("MERGE_MSG"), &statbuf)) {
|
|
|
|
if (strbuf_read_file(&sb, git_path("MERGE_MSG"), 0) < 0)
|
2009-06-27 15:58:46 +00:00
|
|
|
die_errno("could not read MERGE_MSG");
|
2008-02-05 07:04:18 +00:00
|
|
|
hook_arg1 = "merge";
|
2007-11-08 16:59:00 +00:00
|
|
|
} else if (!stat(git_path("SQUASH_MSG"), &statbuf)) {
|
|
|
|
if (strbuf_read_file(&sb, git_path("SQUASH_MSG"), 0) < 0)
|
2009-06-27 15:58:46 +00:00
|
|
|
die_errno("could not read SQUASH_MSG");
|
2008-02-05 07:04:18 +00:00
|
|
|
hook_arg1 = "squash";
|
2007-11-08 16:59:00 +00:00
|
|
|
} else if (template_file && !stat(template_file, &statbuf)) {
|
|
|
|
if (strbuf_read_file(&sb, template_file, 0) < 0)
|
2009-06-27 15:58:46 +00:00
|
|
|
die_errno("could not read '%s'", template_file);
|
2008-02-05 07:04:18 +00:00
|
|
|
hook_arg1 = "template";
|
2007-11-08 16:59:00 +00:00
|
|
|
}
|
|
|
|
|
2008-02-05 07:04:18 +00:00
|
|
|
/*
|
|
|
|
* This final case does not modify the template message,
|
|
|
|
* it just sets the argument to the prepare-commit-msg hook.
|
|
|
|
*/
|
|
|
|
else if (in_merge)
|
|
|
|
hook_arg1 = "merge";
|
|
|
|
|
2007-11-08 16:59:00 +00:00
|
|
|
fp = fopen(git_path(commit_editmsg), "w");
|
|
|
|
if (fp == NULL)
|
2009-06-27 15:58:46 +00:00
|
|
|
die_errno("could not open '%s'", git_path(commit_editmsg));
|
2007-11-08 16:59:00 +00:00
|
|
|
|
2007-12-22 18:46:24 +00:00
|
|
|
if (cleanup_mode != CLEANUP_NONE)
|
|
|
|
stripspace(&sb, 0);
|
2007-11-08 16:59:00 +00:00
|
|
|
|
|
|
|
if (signoff) {
|
2008-10-09 19:12:12 +00:00
|
|
|
struct strbuf sob = STRBUF_INIT;
|
2007-11-11 17:35:58 +00:00
|
|
|
int i;
|
|
|
|
|
|
|
|
strbuf_addstr(&sob, sign_off_header);
|
2007-12-02 21:43:34 +00:00
|
|
|
strbuf_addstr(&sob, fmt_name(getenv("GIT_COMMITTER_NAME"),
|
|
|
|
getenv("GIT_COMMITTER_EMAIL")));
|
2007-11-11 17:35:58 +00:00
|
|
|
strbuf_addch(&sob, '\n');
|
|
|
|
for (i = sb.len - 1; i > 0 && sb.buf[i - 1] != '\n'; i--)
|
|
|
|
; /* do nothing */
|
2007-11-11 17:36:27 +00:00
|
|
|
if (prefixcmp(sb.buf + i, sob.buf)) {
|
2009-11-07 07:06:06 +00:00
|
|
|
if (!i || !ends_rfc2822_footer(&sb))
|
2007-11-11 17:36:27 +00:00
|
|
|
strbuf_addch(&sb, '\n');
|
2007-11-11 17:35:58 +00:00
|
|
|
strbuf_addbuf(&sb, &sob);
|
2007-11-11 17:36:27 +00:00
|
|
|
}
|
2007-11-11 17:35:58 +00:00
|
|
|
strbuf_release(&sob);
|
2007-11-08 16:59:00 +00:00
|
|
|
}
|
|
|
|
|
2007-11-11 17:35:58 +00:00
|
|
|
if (fwrite(sb.buf, 1, sb.len, fp) < sb.len)
|
2009-06-27 15:58:46 +00:00
|
|
|
die_errno("could not write commit template");
|
2007-11-11 17:35:58 +00:00
|
|
|
|
2007-11-08 16:59:00 +00:00
|
|
|
strbuf_release(&sb);
|
|
|
|
|
2008-05-04 16:04:50 +00:00
|
|
|
determine_author_info();
|
|
|
|
|
2008-05-04 16:04:51 +00:00
|
|
|
/* This checks if committer ident is explicitly given */
|
|
|
|
git_committer_info(0);
|
2009-12-07 22:45:27 +00:00
|
|
|
if (use_editor && include_status) {
|
2008-05-04 16:04:50 +00:00
|
|
|
char *author_ident;
|
|
|
|
const char *committer_ident;
|
|
|
|
|
2008-02-05 10:01:46 +00:00
|
|
|
if (in_merge)
|
|
|
|
fprintf(fp,
|
|
|
|
"#\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",
|
|
|
|
git_path("MERGE_HEAD"));
|
|
|
|
|
|
|
|
fprintf(fp,
|
|
|
|
"\n"
|
2008-07-31 07:36:09 +00:00
|
|
|
"# Please enter the commit message for your changes.");
|
2008-02-05 10:01:46 +00:00
|
|
|
if (cleanup_mode == CLEANUP_ALL)
|
2008-07-31 07:36:09 +00:00
|
|
|
fprintf(fp,
|
|
|
|
" Lines starting\n"
|
|
|
|
"# with '#' will be ignored, and an empty"
|
|
|
|
" message aborts the commit.\n");
|
2008-02-05 10:01:46 +00:00
|
|
|
else /* CLEANUP_SPACE, that is. */
|
2008-07-31 07:36:09 +00:00
|
|
|
fprintf(fp,
|
|
|
|
" Lines starting\n"
|
|
|
|
"# with '#' will be kept; you may remove them"
|
|
|
|
" yourself if you want to.\n"
|
|
|
|
"# An empty message aborts the commit.\n");
|
2008-02-05 10:01:46 +00:00
|
|
|
if (only_include_assumed)
|
|
|
|
fprintf(fp, "# %s\n", only_include_assumed);
|
|
|
|
|
2008-05-04 16:04:50 +00:00
|
|
|
author_ident = xstrdup(fmt_name(author_name, author_email));
|
|
|
|
committer_ident = fmt_name(getenv("GIT_COMMITTER_NAME"),
|
|
|
|
getenv("GIT_COMMITTER_EMAIL"));
|
|
|
|
if (strcmp(author_ident, committer_ident))
|
|
|
|
fprintf(fp,
|
2008-05-04 16:04:51 +00:00
|
|
|
"%s"
|
|
|
|
"# Author: %s\n",
|
|
|
|
ident_shown++ ? "" : "#\n",
|
2008-05-04 16:04:50 +00:00
|
|
|
author_ident);
|
|
|
|
free(author_ident);
|
|
|
|
|
2010-01-17 21:54:28 +00:00
|
|
|
if (!user_ident_sufficiently_given())
|
2008-05-04 16:04:51 +00:00
|
|
|
fprintf(fp,
|
|
|
|
"%s"
|
|
|
|
"# Committer: %s\n",
|
|
|
|
ident_shown++ ? "" : "#\n",
|
|
|
|
committer_ident);
|
|
|
|
|
|
|
|
if (ident_shown)
|
|
|
|
fprintf(fp, "#\n");
|
|
|
|
|
2009-08-10 04:59:30 +00:00
|
|
|
saved_color_setting = s->use_color;
|
|
|
|
s->use_color = 0;
|
|
|
|
commitable = run_status(fp, index_file, prefix, 1, s);
|
|
|
|
s->use_color = saved_color_setting;
|
2008-02-05 10:01:46 +00:00
|
|
|
} else {
|
2007-12-23 03:22:29 +00:00
|
|
|
unsigned char sha1[20];
|
2007-12-20 03:23:03 +00:00
|
|
|
const char *parent = "HEAD";
|
2007-11-28 21:13:08 +00:00
|
|
|
|
|
|
|
if (!active_nr && read_cache() < 0)
|
|
|
|
die("Cannot read index");
|
|
|
|
|
2007-12-20 03:23:03 +00:00
|
|
|
if (amend)
|
|
|
|
parent = "HEAD^1";
|
|
|
|
|
2007-12-23 03:22:29 +00:00
|
|
|
if (get_sha1(parent, sha1))
|
2008-02-05 10:01:46 +00:00
|
|
|
commitable = !!active_nr;
|
2009-02-10 14:30:35 +00:00
|
|
|
else
|
|
|
|
commitable = index_differs_from(parent, 0);
|
2008-02-05 10:01:46 +00:00
|
|
|
}
|
2007-12-23 03:22:29 +00:00
|
|
|
|
2008-02-05 10:01:46 +00:00
|
|
|
fclose(fp);
|
2007-11-28 21:13:08 +00:00
|
|
|
|
2008-02-05 10:01:46 +00:00
|
|
|
if (!commitable && !in_merge && !allow_empty &&
|
|
|
|
!(amend && is_a_merge(head_sha1))) {
|
2009-08-10 04:59:30 +00:00
|
|
|
run_status(stdout, index_file, prefix, 0, s);
|
2008-02-05 10:01:46 +00:00
|
|
|
return 0;
|
2007-11-28 21:13:08 +00:00
|
|
|
}
|
|
|
|
|
2008-02-05 10:01:46 +00:00
|
|
|
/*
|
|
|
|
* 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 (!active_cache_tree)
|
|
|
|
active_cache_tree = cache_tree();
|
|
|
|
if (cache_tree_update(active_cache_tree,
|
|
|
|
active_cache, active_nr, 0, 0) < 0) {
|
2008-11-29 03:56:34 +00:00
|
|
|
error("Error building trees");
|
2008-02-05 10:01:46 +00:00
|
|
|
return 0;
|
2007-11-28 21:13:08 +00:00
|
|
|
}
|
2007-11-08 16:59:00 +00:00
|
|
|
|
2008-02-05 07:04:18 +00:00
|
|
|
if (run_hook(index_file, "prepare-commit-msg",
|
|
|
|
git_path(commit_editmsg), hook_arg1, hook_arg2, NULL))
|
|
|
|
return 0;
|
2007-11-08 16:59:00 +00:00
|
|
|
|
2008-02-05 10:01:46 +00:00
|
|
|
if (use_editor) {
|
|
|
|
char index[PATH_MAX];
|
|
|
|
const char *env[2] = { index, NULL };
|
|
|
|
snprintf(index, sizeof(index), "GIT_INDEX_FILE=%s", index_file);
|
2008-07-25 16:28:42 +00:00
|
|
|
if (launch_editor(git_path(commit_editmsg), NULL, env)) {
|
|
|
|
fprintf(stderr,
|
|
|
|
"Please supply the message using either -m or -F option.\n");
|
|
|
|
exit(1);
|
|
|
|
}
|
2008-02-05 10:01:46 +00:00
|
|
|
}
|
2007-11-08 16:59:00 +00:00
|
|
|
|
2008-02-05 10:01:46 +00:00
|
|
|
if (!no_verify &&
|
|
|
|
run_hook(index_file, "commit-msg", git_path(commit_editmsg), NULL)) {
|
|
|
|
return 0;
|
|
|
|
}
|
2007-11-08 16:59:00 +00:00
|
|
|
|
2008-02-05 10:01:46 +00:00
|
|
|
return 1;
|
2007-11-08 16:59:00 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2008-09-10 20:10:32 +00:00
|
|
|
* Find out if the message in the strbuf contains only whitespace and
|
|
|
|
* Signed-off-by lines.
|
2007-11-08 16:59:00 +00:00
|
|
|
*/
|
2008-09-10 20:10:32 +00:00
|
|
|
static int message_is_empty(struct strbuf *sb)
|
2007-11-08 16:59:00 +00:00
|
|
|
{
|
2008-10-09 19:12:12 +00:00
|
|
|
struct strbuf tmpl = STRBUF_INIT;
|
2007-11-08 16:59:00 +00:00
|
|
|
const char *nl;
|
2008-09-10 20:10:32 +00:00
|
|
|
int eol, i, start = 0;
|
2007-11-08 16:59:00 +00:00
|
|
|
|
2007-12-22 18:46:24 +00:00
|
|
|
if (cleanup_mode == CLEANUP_NONE && sb->len)
|
|
|
|
return 0;
|
|
|
|
|
2007-11-08 16:59:00 +00:00
|
|
|
/* See if the template is just a prefix of the message. */
|
|
|
|
if (template_file && strbuf_read_file(&tmpl, template_file, 0) > 0) {
|
2007-12-22 18:46:24 +00:00
|
|
|
stripspace(&tmpl, cleanup_mode == CLEANUP_ALL);
|
2007-11-08 16:59:00 +00:00
|
|
|
if (start + tmpl.len <= sb->len &&
|
|
|
|
memcmp(tmpl.buf, sb->buf + start, tmpl.len) == 0)
|
|
|
|
start += tmpl.len;
|
|
|
|
}
|
|
|
|
strbuf_release(&tmpl);
|
|
|
|
|
|
|
|
/* 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 &&
|
|
|
|
!prefixcmp(sb->buf + i, sign_off_header)) {
|
|
|
|
i = eol;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
while (i < eol)
|
|
|
|
if (!isspace(sb->buf[i++]))
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2008-08-27 06:13:13 +00:00
|
|
|
static const char *find_author_by_nickname(const char *name)
|
|
|
|
{
|
|
|
|
struct rev_info revs;
|
|
|
|
struct commit *commit;
|
|
|
|
struct strbuf buf = STRBUF_INIT;
|
|
|
|
const char *av[20];
|
|
|
|
int ac = 0;
|
|
|
|
|
|
|
|
init_revisions(&revs, NULL);
|
|
|
|
strbuf_addf(&buf, "--author=%s", name);
|
|
|
|
av[++ac] = "--all";
|
|
|
|
av[++ac] = "-i";
|
|
|
|
av[++ac] = buf.buf;
|
|
|
|
av[++ac] = NULL;
|
|
|
|
setup_revisions(ac, av, &revs, NULL);
|
|
|
|
prepare_revision_walk(&revs);
|
|
|
|
commit = get_revision(&revs);
|
|
|
|
if (commit) {
|
2009-10-19 15:48:08 +00:00
|
|
|
struct pretty_print_context ctx = {0};
|
|
|
|
ctx.date_mode = DATE_NORMAL;
|
2008-08-27 06:13:13 +00:00
|
|
|
strbuf_release(&buf);
|
2009-10-19 15:48:08 +00:00
|
|
|
format_commit_message(commit, "%an <%ae>", &buf, &ctx);
|
2008-08-27 06:13:13 +00:00
|
|
|
return strbuf_detach(&buf, NULL);
|
|
|
|
}
|
|
|
|
die("No existing author found with '%s'", name);
|
|
|
|
}
|
|
|
|
|
2009-08-08 06:31:57 +00:00
|
|
|
|
|
|
|
static void handle_untracked_files_arg(struct wt_status *s)
|
|
|
|
{
|
|
|
|
if (!untracked_files_arg)
|
|
|
|
; /* default already initialized */
|
|
|
|
else if (!strcmp(untracked_files_arg, "no"))
|
|
|
|
s->show_untracked_files = SHOW_NO_UNTRACKED_FILES;
|
|
|
|
else if (!strcmp(untracked_files_arg, "normal"))
|
|
|
|
s->show_untracked_files = SHOW_NORMAL_UNTRACKED_FILES;
|
|
|
|
else if (!strcmp(untracked_files_arg, "all"))
|
|
|
|
s->show_untracked_files = SHOW_ALL_UNTRACKED_FILES;
|
|
|
|
else
|
|
|
|
die("Invalid untracked files mode '%s'", untracked_files_arg);
|
|
|
|
}
|
|
|
|
|
2007-12-03 05:02:09 +00:00
|
|
|
static int parse_and_validate_options(int argc, const char *argv[],
|
2008-08-06 18:43:47 +00:00
|
|
|
const char * const usage[],
|
2009-08-10 04:59:30 +00:00
|
|
|
const char *prefix,
|
|
|
|
struct wt_status *s)
|
2007-11-08 16:59:00 +00:00
|
|
|
{
|
|
|
|
int f = 0;
|
|
|
|
|
2009-05-23 18:53:12 +00:00
|
|
|
argc = parse_options(argc, argv, prefix, builtin_commit_options, usage,
|
|
|
|
0);
|
2007-11-08 16:59:00 +00:00
|
|
|
|
2008-08-27 06:13:13 +00:00
|
|
|
if (force_author && !strchr(force_author, '>'))
|
|
|
|
force_author = find_author_by_nickname(force_author);
|
|
|
|
|
2009-11-04 03:20:11 +00:00
|
|
|
if (force_author && renew_authorship)
|
|
|
|
die("Using both --reset-author and --author does not make sense");
|
|
|
|
|
2007-11-11 17:36:39 +00:00
|
|
|
if (logfile || message.len || use_message)
|
2007-12-23 03:25:37 +00:00
|
|
|
use_editor = 0;
|
2007-11-08 16:59:00 +00:00
|
|
|
if (edit_flag)
|
2007-12-23 03:25:37 +00:00
|
|
|
use_editor = 1;
|
2008-02-05 10:01:45 +00:00
|
|
|
if (!use_editor)
|
|
|
|
setenv("GIT_EDITOR", ":", 1);
|
2007-11-08 16:59:00 +00:00
|
|
|
|
|
|
|
if (get_sha1("HEAD", head_sha1))
|
|
|
|
initial_commit = 1;
|
|
|
|
|
|
|
|
/* Sanity check options */
|
|
|
|
if (amend && initial_commit)
|
|
|
|
die("You have nothing to amend.");
|
|
|
|
if (amend && in_merge)
|
2007-12-02 06:07:03 +00:00
|
|
|
die("You are in the middle of a merge -- cannot amend.");
|
2007-11-08 16:59:00 +00:00
|
|
|
|
|
|
|
if (use_message)
|
|
|
|
f++;
|
|
|
|
if (edit_message)
|
|
|
|
f++;
|
|
|
|
if (logfile)
|
|
|
|
f++;
|
|
|
|
if (f > 1)
|
|
|
|
die("Only one of -c/-C/-F can be used.");
|
2007-11-11 17:36:39 +00:00
|
|
|
if (message.len && f > 0)
|
2007-11-08 16:59:00 +00:00
|
|
|
die("Option -m cannot be combined with -c/-C/-F.");
|
|
|
|
if (edit_message)
|
|
|
|
use_message = edit_message;
|
2007-12-14 19:57:22 +00:00
|
|
|
if (amend && !use_message)
|
2007-11-08 16:59:00 +00:00
|
|
|
use_message = "HEAD";
|
2009-11-04 03:20:11 +00:00
|
|
|
if (!use_message && renew_authorship)
|
|
|
|
die("--reset-author can be used only with -C, -c or --amend.");
|
2007-11-08 16:59:00 +00:00
|
|
|
if (use_message) {
|
|
|
|
unsigned char sha1[20];
|
|
|
|
static char utf8[] = "UTF-8";
|
|
|
|
const char *out_enc;
|
|
|
|
char *enc, *end;
|
|
|
|
struct commit *commit;
|
|
|
|
|
|
|
|
if (get_sha1(use_message, sha1))
|
|
|
|
die("could not lookup commit %s", use_message);
|
2008-02-03 08:00:09 +00:00
|
|
|
commit = lookup_commit_reference(sha1);
|
2007-11-08 16:59:00 +00:00
|
|
|
if (!commit || parse_commit(commit))
|
|
|
|
die("could not parse commit %s", use_message);
|
|
|
|
|
|
|
|
enc = strstr(commit->buffer, "\nencoding");
|
|
|
|
if (enc) {
|
|
|
|
end = strchr(enc + 10, '\n');
|
|
|
|
enc = xstrndup(enc + 10, end - (enc + 10));
|
|
|
|
} else {
|
|
|
|
enc = utf8;
|
|
|
|
}
|
|
|
|
out_enc = git_commit_encoding ? git_commit_encoding : utf8;
|
|
|
|
|
|
|
|
if (strcmp(out_enc, enc))
|
|
|
|
use_message_buffer =
|
|
|
|
reencode_string(commit->buffer, out_enc, enc);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If we failed to reencode the buffer, just copy it
|
|
|
|
* byte for byte so the user can try to fix it up.
|
|
|
|
* This also handles the case where input and output
|
|
|
|
* encodings are identical.
|
|
|
|
*/
|
|
|
|
if (use_message_buffer == NULL)
|
|
|
|
use_message_buffer = xstrdup(commit->buffer);
|
|
|
|
if (enc != utf8)
|
|
|
|
free(enc);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!!also + !!only + !!all + !!interactive > 1)
|
|
|
|
die("Only one of --include/--only/--all/--interactive can be used.");
|
|
|
|
if (argc == 0 && (also || (only && !amend)))
|
|
|
|
die("No paths with --include/--only does not make sense.");
|
|
|
|
if (argc == 0 && only && amend)
|
|
|
|
only_include_assumed = "Clever... amending the last one with dirty index.";
|
2008-04-10 11:33:08 +00:00
|
|
|
if (argc > 0 && !also && !only)
|
2007-11-08 16:59:00 +00:00
|
|
|
only_include_assumed = "Explicit paths specified without -i nor -o; assuming --only paths...";
|
2007-12-22 18:46:24 +00:00
|
|
|
if (!cleanup_arg || !strcmp(cleanup_arg, "default"))
|
|
|
|
cleanup_mode = use_editor ? CLEANUP_ALL : CLEANUP_SPACE;
|
|
|
|
else if (!strcmp(cleanup_arg, "verbatim"))
|
|
|
|
cleanup_mode = CLEANUP_NONE;
|
|
|
|
else if (!strcmp(cleanup_arg, "whitespace"))
|
|
|
|
cleanup_mode = CLEANUP_SPACE;
|
|
|
|
else if (!strcmp(cleanup_arg, "strip"))
|
|
|
|
cleanup_mode = CLEANUP_ALL;
|
|
|
|
else
|
|
|
|
die("Invalid cleanup mode %s", cleanup_arg);
|
2007-11-08 16:59:00 +00:00
|
|
|
|
2009-08-08 06:31:57 +00:00
|
|
|
handle_untracked_files_arg(s);
|
2008-06-05 08:31:19 +00:00
|
|
|
|
2007-11-08 16:59:00 +00:00
|
|
|
if (all && argc > 0)
|
|
|
|
die("Paths with -a does not make sense.");
|
|
|
|
else if (interactive && argc > 0)
|
|
|
|
die("Paths with --interactive does not make sense.");
|
|
|
|
|
2009-09-05 08:59:56 +00:00
|
|
|
if (null_termination && status_format == STATUS_FORMAT_LONG)
|
|
|
|
status_format = STATUS_FORMAT_PORCELAIN;
|
|
|
|
if (status_format != STATUS_FORMAT_LONG)
|
|
|
|
dry_run = 1;
|
|
|
|
|
2007-11-08 16:59:00 +00:00
|
|
|
return argc;
|
|
|
|
}
|
|
|
|
|
2009-08-10 04:59:30 +00:00
|
|
|
static int dry_run_commit(int argc, const char **argv, const char *prefix,
|
|
|
|
struct wt_status *s)
|
2007-11-08 16:59:00 +00:00
|
|
|
{
|
|
|
|
int commitable;
|
2009-08-08 06:03:36 +00:00
|
|
|
const char *index_file;
|
2007-11-08 16:59:00 +00:00
|
|
|
|
2009-08-08 06:03:36 +00:00
|
|
|
index_file = prepare_index(argc, argv, prefix, 1);
|
2009-08-10 04:59:30 +00:00
|
|
|
commitable = run_status(stdout, index_file, prefix, 0, s);
|
2009-08-08 06:03:36 +00:00
|
|
|
rollback_index_files();
|
2007-11-08 16:59:00 +00:00
|
|
|
|
2009-08-08 06:03:36 +00:00
|
|
|
return commitable ? 0 : 1;
|
|
|
|
}
|
|
|
|
|
2009-08-10 06:12:19 +00:00
|
|
|
static int parse_status_slot(const char *var, int offset)
|
|
|
|
{
|
|
|
|
if (!strcasecmp(var+offset, "header"))
|
|
|
|
return WT_STATUS_HEADER;
|
|
|
|
if (!strcasecmp(var+offset, "updated")
|
|
|
|
|| !strcasecmp(var+offset, "added"))
|
|
|
|
return WT_STATUS_UPDATED;
|
|
|
|
if (!strcasecmp(var+offset, "changed"))
|
|
|
|
return WT_STATUS_CHANGED;
|
|
|
|
if (!strcasecmp(var+offset, "untracked"))
|
|
|
|
return WT_STATUS_UNTRACKED;
|
|
|
|
if (!strcasecmp(var+offset, "nobranch"))
|
|
|
|
return WT_STATUS_NOBRANCH;
|
|
|
|
if (!strcasecmp(var+offset, "unmerged"))
|
|
|
|
return WT_STATUS_UNMERGED;
|
ignore unknown color configuration
When parsing the config file, if there is a value that is
syntactically correct but unused, we generally ignore it.
This lets non-core porcelains store arbitrary information in
the config file, and it means that configuration files can
be shared between new and old versions of git (the old
versions might simply ignore certain configuration).
The one exception to this is color configuration; if we
encounter a color.{diff,branch,status}.$slot variable, we
die if it is not one of the recognized slots (presumably as
a safety valve for user misconfiguration). This behavior
has existed since 801235c (diff --color: use
$GIT_DIR/config, 2006-06-24), but hasn't yet caused a
problem. No porcelain has wanted to store extra colors, and
we once a color area (like color.diff) has been introduced,
we've never changed the set of color slots.
However, that changed recently with the addition of
color.diff.func. Now a user with color.diff.func in their
config can no longer freely switch between v1.6.6 and older
versions; the old versions will complain about the existence
of the variable.
This patch loosens the check to match the rest of
git-config; unknown color slots are simply ignored. This
doesn't fix this particular problem, as the older version
(without this patch) is the problem, but it at least
prevents it from happening again in the future.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2009-12-12 12:25:24 +00:00
|
|
|
return -1;
|
2009-08-10 06:12:19 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int git_status_config(const char *k, const char *v, void *cb)
|
|
|
|
{
|
|
|
|
struct wt_status *s = cb;
|
|
|
|
|
|
|
|
if (!strcmp(k, "status.submodulesummary")) {
|
|
|
|
int is_bool;
|
|
|
|
s->submodule_summary = git_config_bool_or_int(k, v, &is_bool);
|
|
|
|
if (is_bool && s->submodule_summary)
|
|
|
|
s->submodule_summary = -1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
if (!strcmp(k, "status.color") || !strcmp(k, "color.status")) {
|
|
|
|
s->use_color = git_config_colorbool(k, v, -1);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
if (!prefixcmp(k, "status.color.") || !prefixcmp(k, "color.status.")) {
|
|
|
|
int slot = parse_status_slot(k, 13);
|
ignore unknown color configuration
When parsing the config file, if there is a value that is
syntactically correct but unused, we generally ignore it.
This lets non-core porcelains store arbitrary information in
the config file, and it means that configuration files can
be shared between new and old versions of git (the old
versions might simply ignore certain configuration).
The one exception to this is color configuration; if we
encounter a color.{diff,branch,status}.$slot variable, we
die if it is not one of the recognized slots (presumably as
a safety valve for user misconfiguration). This behavior
has existed since 801235c (diff --color: use
$GIT_DIR/config, 2006-06-24), but hasn't yet caused a
problem. No porcelain has wanted to store extra colors, and
we once a color area (like color.diff) has been introduced,
we've never changed the set of color slots.
However, that changed recently with the addition of
color.diff.func. Now a user with color.diff.func in their
config can no longer freely switch between v1.6.6 and older
versions; the old versions will complain about the existence
of the variable.
This patch loosens the check to match the rest of
git-config; unknown color slots are simply ignored. This
doesn't fix this particular problem, as the older version
(without this patch) is the problem, but it at least
prevents it from happening again in the future.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2009-12-12 12:25:24 +00:00
|
|
|
if (slot < 0)
|
|
|
|
return 0;
|
2009-08-10 06:12:19 +00:00
|
|
|
if (!v)
|
|
|
|
return config_error_nonbool(k);
|
|
|
|
color_parse(v, k, s->color_palette[slot]);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
if (!strcmp(k, "status.relativepaths")) {
|
|
|
|
s->relative_paths = git_config_bool(k, v);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
if (!strcmp(k, "status.showuntrackedfiles")) {
|
|
|
|
if (!v)
|
|
|
|
return config_error_nonbool(k);
|
|
|
|
else if (!strcmp(v, "no"))
|
|
|
|
s->show_untracked_files = SHOW_NO_UNTRACKED_FILES;
|
|
|
|
else if (!strcmp(v, "normal"))
|
|
|
|
s->show_untracked_files = SHOW_NORMAL_UNTRACKED_FILES;
|
|
|
|
else if (!strcmp(v, "all"))
|
|
|
|
s->show_untracked_files = SHOW_ALL_UNTRACKED_FILES;
|
|
|
|
else
|
|
|
|
return error("Invalid untracked files mode '%s'", v);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
return git_diff_ui_config(k, v, NULL);
|
|
|
|
}
|
|
|
|
|
2009-08-08 06:03:36 +00:00
|
|
|
int cmd_status(int argc, const char **argv, const char *prefix)
|
|
|
|
{
|
2009-08-10 04:59:30 +00:00
|
|
|
struct wt_status s;
|
2009-08-08 06:31:57 +00:00
|
|
|
unsigned char sha1[20];
|
2009-08-15 09:27:39 +00:00
|
|
|
static struct option builtin_status_options[] = {
|
2009-08-08 06:31:57 +00:00
|
|
|
OPT__VERBOSE(&verbose),
|
2009-09-05 08:54:14 +00:00
|
|
|
OPT_SET_INT('s', "short", &status_format,
|
|
|
|
"show status concisely", STATUS_FORMAT_SHORT),
|
2009-09-05 08:55:37 +00:00
|
|
|
OPT_SET_INT(0, "porcelain", &status_format,
|
|
|
|
"show porcelain output format",
|
|
|
|
STATUS_FORMAT_PORCELAIN),
|
git stat -s: short status output
Give -s(hort) option to "git stat" that shows the status of paths in a
more concise way.
XY PATH1 -> PATH2
format to be more machine readable than output from "git status", which is
about previewing of "git commit" with the same arguments.
PATH1 is the path in the HEAD, and " -> PATH2" part is shown only when
PATH1 corresponds to a different path in the index/worktree.
For unmerged entries, X shows the status of stage #2 (i.e. ours) and Y
shows the status of stage #3 (i.e. theirs). For entries that do not have
conflicts, X shows the status of the index, and Y shows the status of the
work tree. For untracked paths, XY are "??".
X Y Meaning
-------------------------------------------------
[MD] not updated
M [ MD] updated in index
A [ MD] added to index
D [ MD] deleted from index
R [ MD] renamed in index
C [ MD] copied in index
[MARC] index and work tree matches
[ MARC] M work tree changed since index
[ MARC] D deleted in work tree
D D unmerged, both deleted
A U unmerged, added by us
U D unmerged, deleted by them
U A unmerged, added by them
D U unmerged, deleted by us
A A unmerged, both added
U U unmerged, both modified
? ? untracked
When given -z option, the records are terminated by NUL characters for
better machine readability. Because the traditional long format is
designed for human consumption, NUL termination does not make sense.
For this reason, -z option implies -s (short output).
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2009-08-05 06:55:22 +00:00
|
|
|
OPT_BOOLEAN('z', "null", &null_termination,
|
|
|
|
"terminate entries with NUL"),
|
2009-08-08 06:31:57 +00:00
|
|
|
{ OPTION_STRING, 'u', "untracked-files", &untracked_files_arg,
|
|
|
|
"mode",
|
|
|
|
"show untracked files, optional modes: all, normal, no. (Default: all)",
|
|
|
|
PARSE_OPT_OPTARG, NULL, (intptr_t)"all" },
|
|
|
|
OPT_END(),
|
|
|
|
};
|
|
|
|
|
2009-09-05 08:54:14 +00:00
|
|
|
if (null_termination && status_format == STATUS_FORMAT_LONG)
|
2009-09-05 08:55:37 +00:00
|
|
|
status_format = STATUS_FORMAT_PORCELAIN;
|
2009-08-10 04:59:30 +00:00
|
|
|
|
|
|
|
wt_status_prepare(&s);
|
|
|
|
git_config(git_status_config, &s);
|
2009-12-12 07:45:24 +00:00
|
|
|
in_merge = file_exists(git_path("MERGE_HEAD"));
|
2009-08-08 06:31:57 +00:00
|
|
|
argc = parse_options(argc, argv, prefix,
|
2009-08-15 09:27:39 +00:00
|
|
|
builtin_status_options,
|
|
|
|
builtin_status_usage, 0);
|
2009-08-08 06:31:57 +00:00
|
|
|
handle_untracked_files_arg(&s);
|
|
|
|
|
|
|
|
if (*argv)
|
|
|
|
s.pathspec = get_pathspec(prefix, argv);
|
|
|
|
|
2010-02-17 20:30:41 +00:00
|
|
|
read_cache_preload(s.pathspec);
|
2010-01-14 15:02:21 +00:00
|
|
|
refresh_index(&the_index, REFRESH_QUIET|REFRESH_UNMERGED, s.pathspec, NULL, NULL);
|
2009-08-08 06:31:57 +00:00
|
|
|
s.is_initial = get_sha1(s.reference, sha1) ? 1 : 0;
|
2009-12-12 07:53:41 +00:00
|
|
|
s.in_merge = in_merge;
|
2009-08-08 06:31:57 +00:00
|
|
|
wt_status_collect(&s);
|
|
|
|
|
2009-12-07 05:26:25 +00:00
|
|
|
if (s.relative_paths)
|
|
|
|
s.prefix = prefix;
|
2009-08-10 04:59:30 +00:00
|
|
|
if (s.use_color == -1)
|
|
|
|
s.use_color = git_use_color_default;
|
2009-01-08 18:53:05 +00:00
|
|
|
if (diff_use_color_default == -1)
|
|
|
|
diff_use_color_default = git_use_color_default;
|
|
|
|
|
2009-09-05 08:54:14 +00:00
|
|
|
switch (status_format) {
|
|
|
|
case STATUS_FORMAT_SHORT:
|
2009-12-05 15:04:37 +00:00
|
|
|
wt_shortstatus_print(&s, null_termination);
|
2009-09-05 08:54:14 +00:00
|
|
|
break;
|
2009-09-05 08:55:37 +00:00
|
|
|
case STATUS_FORMAT_PORCELAIN:
|
2009-12-07 05:17:15 +00:00
|
|
|
wt_porcelain_print(&s, null_termination);
|
2009-09-05 08:55:37 +00:00
|
|
|
break;
|
2009-09-05 08:54:14 +00:00
|
|
|
case STATUS_FORMAT_LONG:
|
git stat -s: short status output
Give -s(hort) option to "git stat" that shows the status of paths in a
more concise way.
XY PATH1 -> PATH2
format to be more machine readable than output from "git status", which is
about previewing of "git commit" with the same arguments.
PATH1 is the path in the HEAD, and " -> PATH2" part is shown only when
PATH1 corresponds to a different path in the index/worktree.
For unmerged entries, X shows the status of stage #2 (i.e. ours) and Y
shows the status of stage #3 (i.e. theirs). For entries that do not have
conflicts, X shows the status of the index, and Y shows the status of the
work tree. For untracked paths, XY are "??".
X Y Meaning
-------------------------------------------------
[MD] not updated
M [ MD] updated in index
A [ MD] added to index
D [ MD] deleted from index
R [ MD] renamed in index
C [ MD] copied in index
[MARC] index and work tree matches
[ MARC] M work tree changed since index
[ MARC] D deleted in work tree
D D unmerged, both deleted
A U unmerged, added by us
U D unmerged, deleted by them
U A unmerged, added by them
D U unmerged, deleted by us
A A unmerged, both added
U U unmerged, both modified
? ? untracked
When given -z option, the records are terminated by NUL characters for
better machine readability. Because the traditional long format is
designed for human consumption, NUL termination does not make sense.
For this reason, -z option implies -s (short output).
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2009-08-05 06:55:22 +00:00
|
|
|
s.verbose = verbose;
|
|
|
|
wt_status_print(&s);
|
2009-09-05 08:54:14 +00:00
|
|
|
break;
|
git stat -s: short status output
Give -s(hort) option to "git stat" that shows the status of paths in a
more concise way.
XY PATH1 -> PATH2
format to be more machine readable than output from "git status", which is
about previewing of "git commit" with the same arguments.
PATH1 is the path in the HEAD, and " -> PATH2" part is shown only when
PATH1 corresponds to a different path in the index/worktree.
For unmerged entries, X shows the status of stage #2 (i.e. ours) and Y
shows the status of stage #3 (i.e. theirs). For entries that do not have
conflicts, X shows the status of the index, and Y shows the status of the
work tree. For untracked paths, XY are "??".
X Y Meaning
-------------------------------------------------
[MD] not updated
M [ MD] updated in index
A [ MD] added to index
D [ MD] deleted from index
R [ MD] renamed in index
C [ MD] copied in index
[MARC] index and work tree matches
[ MARC] M work tree changed since index
[ MARC] D deleted in work tree
D D unmerged, both deleted
A U unmerged, added by us
U D unmerged, deleted by them
U A unmerged, added by them
D U unmerged, deleted by us
A A unmerged, both added
U U unmerged, both modified
? ? untracked
When given -z option, the records are terminated by NUL characters for
better machine readability. Because the traditional long format is
designed for human consumption, NUL termination does not make sense.
For this reason, -z option implies -s (short output).
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2009-08-05 06:55:22 +00:00
|
|
|
}
|
2009-08-08 06:31:57 +00:00
|
|
|
return 0;
|
2007-11-08 16:59:00 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void print_summary(const char *prefix, const unsigned char *sha1)
|
|
|
|
{
|
|
|
|
struct rev_info rev;
|
|
|
|
struct commit *commit;
|
commit: show interesting ident information in summary
There are a few cases of user identity information that we consider
interesting:
(1) When the author and committer identities do not match.
(2) When the committer identity was picked automatically from the
username, hostname and GECOS information.
In these cases, we already show the information in the commit
message template. However, users do not always see that template
because they might use "-m" or "-F". With this patch, we show these
interesting cases after the commit, along with the subject and
change summary. The new output looks like:
$ git commit \
-m "federalist papers" \
--author='Publius <alexander@hamilton.com>'
[master 3d226a7] federalist papers
Author: Publius <alexander@hamilton.com>
1 files changed, 1 insertions(+), 0 deletions(-)
for case (1), and:
$ git config --global --unset user.name
$ git config --global --unset user.email
$ git commit -m foo
[master 7c2a927] foo
Committer: Jeff King <peff@c-71-185-130-222.hsd1.va.comcast.net>
Your name and email address were configured automatically based
on your username and hostname. Please check that they are accurate.
You can suppress this message by setting them explicitly:
git config --global user.name Your Name
git config --global user.email you@example.com
If the identity used for this commit is wrong, you can fix it with:
git commit --amend --author='Your Name <you@example.com>'
1 files changed, 1 insertions(+), 0 deletions(-)
for case (2).
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2010-01-13 17:39:51 +00:00
|
|
|
struct strbuf format = STRBUF_INIT;
|
2008-10-01 22:31:25 +00:00
|
|
|
unsigned char junk_sha1[20];
|
|
|
|
const char *head = resolve_ref("HEAD", junk_sha1, 0, NULL);
|
commit: show interesting ident information in summary
There are a few cases of user identity information that we consider
interesting:
(1) When the author and committer identities do not match.
(2) When the committer identity was picked automatically from the
username, hostname and GECOS information.
In these cases, we already show the information in the commit
message template. However, users do not always see that template
because they might use "-m" or "-F". With this patch, we show these
interesting cases after the commit, along with the subject and
change summary. The new output looks like:
$ git commit \
-m "federalist papers" \
--author='Publius <alexander@hamilton.com>'
[master 3d226a7] federalist papers
Author: Publius <alexander@hamilton.com>
1 files changed, 1 insertions(+), 0 deletions(-)
for case (1), and:
$ git config --global --unset user.name
$ git config --global --unset user.email
$ git commit -m foo
[master 7c2a927] foo
Committer: Jeff King <peff@c-71-185-130-222.hsd1.va.comcast.net>
Your name and email address were configured automatically based
on your username and hostname. Please check that they are accurate.
You can suppress this message by setting them explicitly:
git config --global user.name Your Name
git config --global user.email you@example.com
If the identity used for this commit is wrong, you can fix it with:
git commit --amend --author='Your Name <you@example.com>'
1 files changed, 1 insertions(+), 0 deletions(-)
for case (2).
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2010-01-13 17:39:51 +00:00
|
|
|
struct pretty_print_context pctx = {0};
|
|
|
|
struct strbuf author_ident = STRBUF_INIT;
|
|
|
|
struct strbuf committer_ident = STRBUF_INIT;
|
2007-11-08 16:59:00 +00:00
|
|
|
|
|
|
|
commit = lookup_commit(sha1);
|
|
|
|
if (!commit)
|
2007-12-02 06:07:03 +00:00
|
|
|
die("couldn't look up newly created commit");
|
2007-11-08 16:59:00 +00:00
|
|
|
if (!commit || parse_commit(commit))
|
|
|
|
die("could not parse newly created commit");
|
|
|
|
|
commit: show interesting ident information in summary
There are a few cases of user identity information that we consider
interesting:
(1) When the author and committer identities do not match.
(2) When the committer identity was picked automatically from the
username, hostname and GECOS information.
In these cases, we already show the information in the commit
message template. However, users do not always see that template
because they might use "-m" or "-F". With this patch, we show these
interesting cases after the commit, along with the subject and
change summary. The new output looks like:
$ git commit \
-m "federalist papers" \
--author='Publius <alexander@hamilton.com>'
[master 3d226a7] federalist papers
Author: Publius <alexander@hamilton.com>
1 files changed, 1 insertions(+), 0 deletions(-)
for case (1), and:
$ git config --global --unset user.name
$ git config --global --unset user.email
$ git commit -m foo
[master 7c2a927] foo
Committer: Jeff King <peff@c-71-185-130-222.hsd1.va.comcast.net>
Your name and email address were configured automatically based
on your username and hostname. Please check that they are accurate.
You can suppress this message by setting them explicitly:
git config --global user.name Your Name
git config --global user.email you@example.com
If the identity used for this commit is wrong, you can fix it with:
git commit --amend --author='Your Name <you@example.com>'
1 files changed, 1 insertions(+), 0 deletions(-)
for case (2).
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2010-01-13 17:39:51 +00:00
|
|
|
strbuf_addstr(&format, "format:%h] %s");
|
|
|
|
|
|
|
|
format_commit_message(commit, "%an <%ae>", &author_ident, &pctx);
|
|
|
|
format_commit_message(commit, "%cn <%ce>", &committer_ident, &pctx);
|
|
|
|
if (strbuf_cmp(&author_ident, &committer_ident)) {
|
|
|
|
strbuf_addstr(&format, "\n Author: ");
|
|
|
|
strbuf_addbuf_percentquote(&format, &author_ident);
|
|
|
|
}
|
2010-01-17 21:59:36 +00:00
|
|
|
if (!user_ident_sufficiently_given()) {
|
commit: show interesting ident information in summary
There are a few cases of user identity information that we consider
interesting:
(1) When the author and committer identities do not match.
(2) When the committer identity was picked automatically from the
username, hostname and GECOS information.
In these cases, we already show the information in the commit
message template. However, users do not always see that template
because they might use "-m" or "-F". With this patch, we show these
interesting cases after the commit, along with the subject and
change summary. The new output looks like:
$ git commit \
-m "federalist papers" \
--author='Publius <alexander@hamilton.com>'
[master 3d226a7] federalist papers
Author: Publius <alexander@hamilton.com>
1 files changed, 1 insertions(+), 0 deletions(-)
for case (1), and:
$ git config --global --unset user.name
$ git config --global --unset user.email
$ git commit -m foo
[master 7c2a927] foo
Committer: Jeff King <peff@c-71-185-130-222.hsd1.va.comcast.net>
Your name and email address were configured automatically based
on your username and hostname. Please check that they are accurate.
You can suppress this message by setting them explicitly:
git config --global user.name Your Name
git config --global user.email you@example.com
If the identity used for this commit is wrong, you can fix it with:
git commit --amend --author='Your Name <you@example.com>'
1 files changed, 1 insertions(+), 0 deletions(-)
for case (2).
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2010-01-13 17:39:51 +00:00
|
|
|
strbuf_addstr(&format, "\n Committer: ");
|
|
|
|
strbuf_addbuf_percentquote(&format, &committer_ident);
|
2010-01-13 20:17:08 +00:00
|
|
|
if (advice_implicit_identity) {
|
|
|
|
strbuf_addch(&format, '\n');
|
|
|
|
strbuf_addstr(&format, implicit_ident_advice);
|
|
|
|
}
|
commit: show interesting ident information in summary
There are a few cases of user identity information that we consider
interesting:
(1) When the author and committer identities do not match.
(2) When the committer identity was picked automatically from the
username, hostname and GECOS information.
In these cases, we already show the information in the commit
message template. However, users do not always see that template
because they might use "-m" or "-F". With this patch, we show these
interesting cases after the commit, along with the subject and
change summary. The new output looks like:
$ git commit \
-m "federalist papers" \
--author='Publius <alexander@hamilton.com>'
[master 3d226a7] federalist papers
Author: Publius <alexander@hamilton.com>
1 files changed, 1 insertions(+), 0 deletions(-)
for case (1), and:
$ git config --global --unset user.name
$ git config --global --unset user.email
$ git commit -m foo
[master 7c2a927] foo
Committer: Jeff King <peff@c-71-185-130-222.hsd1.va.comcast.net>
Your name and email address were configured automatically based
on your username and hostname. Please check that they are accurate.
You can suppress this message by setting them explicitly:
git config --global user.name Your Name
git config --global user.email you@example.com
If the identity used for this commit is wrong, you can fix it with:
git commit --amend --author='Your Name <you@example.com>'
1 files changed, 1 insertions(+), 0 deletions(-)
for case (2).
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2010-01-13 17:39:51 +00:00
|
|
|
}
|
|
|
|
strbuf_release(&author_ident);
|
|
|
|
strbuf_release(&committer_ident);
|
|
|
|
|
2007-11-08 16:59:00 +00:00
|
|
|
init_revisions(&rev, prefix);
|
|
|
|
setup_revisions(0, NULL, &rev, NULL);
|
|
|
|
|
|
|
|
rev.abbrev = 0;
|
|
|
|
rev.diff = 1;
|
|
|
|
rev.diffopt.output_format =
|
|
|
|
DIFF_FORMAT_SHORTSTAT | DIFF_FORMAT_SUMMARY;
|
|
|
|
|
|
|
|
rev.verbose_header = 1;
|
|
|
|
rev.show_root_diff = 1;
|
commit: show interesting ident information in summary
There are a few cases of user identity information that we consider
interesting:
(1) When the author and committer identities do not match.
(2) When the committer identity was picked automatically from the
username, hostname and GECOS information.
In these cases, we already show the information in the commit
message template. However, users do not always see that template
because they might use "-m" or "-F". With this patch, we show these
interesting cases after the commit, along with the subject and
change summary. The new output looks like:
$ git commit \
-m "federalist papers" \
--author='Publius <alexander@hamilton.com>'
[master 3d226a7] federalist papers
Author: Publius <alexander@hamilton.com>
1 files changed, 1 insertions(+), 0 deletions(-)
for case (1), and:
$ git config --global --unset user.name
$ git config --global --unset user.email
$ git commit -m foo
[master 7c2a927] foo
Committer: Jeff King <peff@c-71-185-130-222.hsd1.va.comcast.net>
Your name and email address were configured automatically based
on your username and hostname. Please check that they are accurate.
You can suppress this message by setting them explicitly:
git config --global user.name Your Name
git config --global user.email you@example.com
If the identity used for this commit is wrong, you can fix it with:
git commit --amend --author='Your Name <you@example.com>'
1 files changed, 1 insertions(+), 0 deletions(-)
for case (2).
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2010-01-13 17:39:51 +00:00
|
|
|
get_commit_format(format.buf, &rev);
|
2007-12-11 05:02:26 +00:00
|
|
|
rev.always_show_header = 0;
|
2007-12-16 23:05:39 +00:00
|
|
|
rev.diffopt.detect_rename = 1;
|
|
|
|
rev.diffopt.rename_limit = 100;
|
|
|
|
rev.diffopt.break_opt = 0;
|
2007-12-16 23:03:58 +00:00
|
|
|
diff_setup_done(&rev.diffopt);
|
2007-11-08 16:59:00 +00:00
|
|
|
|
2009-01-19 22:45:16 +00:00
|
|
|
printf("[%s%s ",
|
2008-10-01 22:31:25 +00:00
|
|
|
!prefixcmp(head, "refs/heads/") ?
|
|
|
|
head + 11 :
|
|
|
|
!strcmp(head, "HEAD") ?
|
|
|
|
"detached HEAD" :
|
|
|
|
head,
|
|
|
|
initial_commit ? " (root-commit)" : "");
|
2007-11-08 16:59:00 +00:00
|
|
|
|
2007-12-11 05:02:26 +00:00
|
|
|
if (!log_tree_commit(&rev, commit)) {
|
2009-10-19 15:48:08 +00:00
|
|
|
struct pretty_print_context ctx = {0};
|
2007-12-11 05:02:26 +00:00
|
|
|
struct strbuf buf = STRBUF_INIT;
|
2009-10-19 15:48:08 +00:00
|
|
|
ctx.date_mode = DATE_NORMAL;
|
commit: show interesting ident information in summary
There are a few cases of user identity information that we consider
interesting:
(1) When the author and committer identities do not match.
(2) When the committer identity was picked automatically from the
username, hostname and GECOS information.
In these cases, we already show the information in the commit
message template. However, users do not always see that template
because they might use "-m" or "-F". With this patch, we show these
interesting cases after the commit, along with the subject and
change summary. The new output looks like:
$ git commit \
-m "federalist papers" \
--author='Publius <alexander@hamilton.com>'
[master 3d226a7] federalist papers
Author: Publius <alexander@hamilton.com>
1 files changed, 1 insertions(+), 0 deletions(-)
for case (1), and:
$ git config --global --unset user.name
$ git config --global --unset user.email
$ git commit -m foo
[master 7c2a927] foo
Committer: Jeff King <peff@c-71-185-130-222.hsd1.va.comcast.net>
Your name and email address were configured automatically based
on your username and hostname. Please check that they are accurate.
You can suppress this message by setting them explicitly:
git config --global user.name Your Name
git config --global user.email you@example.com
If the identity used for this commit is wrong, you can fix it with:
git commit --amend --author='Your Name <you@example.com>'
1 files changed, 1 insertions(+), 0 deletions(-)
for case (2).
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2010-01-13 17:39:51 +00:00
|
|
|
format_commit_message(commit, format.buf + 7, &buf, &ctx);
|
2007-12-11 05:02:26 +00:00
|
|
|
printf("%s\n", buf.buf);
|
|
|
|
strbuf_release(&buf);
|
|
|
|
}
|
2010-01-17 08:57:51 +00:00
|
|
|
strbuf_release(&format);
|
2007-11-08 16:59:00 +00:00
|
|
|
}
|
|
|
|
|
2008-07-23 23:09:35 +00:00
|
|
|
static int git_commit_config(const char *k, const char *v, void *cb)
|
2007-11-08 16:59:00 +00:00
|
|
|
{
|
2009-08-10 04:59:30 +00:00
|
|
|
struct wt_status *s = cb;
|
|
|
|
|
2008-07-05 05:24:40 +00:00
|
|
|
if (!strcmp(k, "commit.template"))
|
2009-11-17 17:24:25 +00:00
|
|
|
return git_config_pathname(&template_file, k, v);
|
2009-12-07 22:45:27 +00:00
|
|
|
if (!strcmp(k, "commit.status")) {
|
|
|
|
include_status = git_config_bool(k, v);
|
|
|
|
return 0;
|
|
|
|
}
|
2007-11-08 16:59:00 +00:00
|
|
|
|
2009-08-10 04:59:30 +00:00
|
|
|
return git_status_config(k, v, s);
|
2007-11-08 16:59:00 +00:00
|
|
|
}
|
|
|
|
|
2010-03-12 17:04:28 +00:00
|
|
|
static const char post_rewrite_hook[] = "hooks/post-rewrite";
|
|
|
|
|
|
|
|
static int run_rewrite_hook(const unsigned char *oldsha1,
|
|
|
|
const unsigned char *newsha1)
|
|
|
|
{
|
|
|
|
/* oldsha1 SP newsha1 LF NUL */
|
|
|
|
static char buf[2*40 + 3];
|
|
|
|
struct child_process proc;
|
|
|
|
const char *argv[3];
|
|
|
|
int code;
|
|
|
|
size_t n;
|
|
|
|
|
|
|
|
if (access(git_path(post_rewrite_hook), X_OK) < 0)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
argv[0] = git_path(post_rewrite_hook);
|
|
|
|
argv[1] = "amend";
|
|
|
|
argv[2] = NULL;
|
|
|
|
|
|
|
|
memset(&proc, 0, sizeof(proc));
|
|
|
|
proc.argv = argv;
|
|
|
|
proc.in = -1;
|
|
|
|
proc.stdout_to_stderr = 1;
|
|
|
|
|
|
|
|
code = start_command(&proc);
|
|
|
|
if (code)
|
|
|
|
return code;
|
|
|
|
n = snprintf(buf, sizeof(buf), "%s %s\n",
|
|
|
|
sha1_to_hex(oldsha1), sha1_to_hex(newsha1));
|
|
|
|
write_in_full(proc.in, buf, n);
|
|
|
|
close(proc.in);
|
|
|
|
return finish_command(&proc);
|
|
|
|
}
|
|
|
|
|
2007-11-08 16:59:00 +00:00
|
|
|
int cmd_commit(int argc, const char **argv, const char *prefix)
|
|
|
|
{
|
2008-10-09 19:12:12 +00:00
|
|
|
struct strbuf sb = STRBUF_INIT;
|
2007-11-08 16:59:00 +00:00
|
|
|
const char *index_file, *reflog_msg;
|
2007-11-22 02:54:49 +00:00
|
|
|
char *nl, *p;
|
2007-11-08 16:59:00 +00:00
|
|
|
unsigned char commit_sha1[20];
|
|
|
|
struct ref_lock *ref_lock;
|
2008-09-10 20:10:32 +00:00
|
|
|
struct commit_list *parents = NULL, **pptr = &parents;
|
builtin-commit: use reduce_heads() only when appropriate
Since commit 6bb6b034 (builtin-commit: use commit_tree(), 2008-09-10),
builtin-commit performs a reduce_heads() unconditionally. However,
it's not always needed, and in some cases even harmful.
reduce_heads() is not needed for the initial commit or for an
"ordinary" commit, because they don't have any or have only one
parent, respectively.
reduce_heads() must be avoided when 'git commit' is run after a 'git
merge --no-ff --no-commit', otherwise it will turn the
non-fast-forward merge into fast-forward. For the same reason,
reduce_heads() must be avoided when amending such a merge commit.
To resolve this issue, 'git merge' will write info about whether
fast-forward is allowed or not to $GIT_DIR/MERGE_MODE. Based on this
info, 'git commit' will only perform reduce_heads() when it's
committing a merge and fast-forward is enabled.
Also add test cases to ensure that non-fast-forward merges are
committed and amended properly.
Signed-off-by: Miklos Vajna <vmiklos@frugalware.org>
Signed-off-by: SZEDER Gábor <szeder@ira.uka.de>
Signed-off-by: Shawn O. Pearce <spearce@spearce.org>
2008-10-03 12:04:47 +00:00
|
|
|
struct stat statbuf;
|
|
|
|
int allow_fast_forward = 1;
|
2009-08-10 04:59:30 +00:00
|
|
|
struct wt_status s;
|
2007-11-08 16:59:00 +00:00
|
|
|
|
2009-08-10 04:59:30 +00:00
|
|
|
wt_status_prepare(&s);
|
|
|
|
git_config(git_commit_config, &s);
|
2009-12-12 07:45:24 +00:00
|
|
|
in_merge = file_exists(git_path("MERGE_HEAD"));
|
2009-12-12 07:53:41 +00:00
|
|
|
s.in_merge = in_merge;
|
2007-11-08 16:59:00 +00:00
|
|
|
|
2009-08-10 04:59:30 +00:00
|
|
|
if (s.use_color == -1)
|
|
|
|
s.use_color = git_use_color_default;
|
|
|
|
argc = parse_and_validate_options(argc, argv, builtin_commit_usage,
|
|
|
|
prefix, &s);
|
2009-08-15 09:14:14 +00:00
|
|
|
if (dry_run) {
|
|
|
|
if (diff_use_color_default == -1)
|
|
|
|
diff_use_color_default = git_use_color_default;
|
2009-08-10 04:59:30 +00:00
|
|
|
return dry_run_commit(argc, argv, prefix, &s);
|
2009-08-15 09:14:14 +00:00
|
|
|
}
|
2009-08-05 06:49:33 +00:00
|
|
|
index_file = prepare_index(argc, argv, prefix, 0);
|
2007-11-08 16:59:00 +00:00
|
|
|
|
2008-02-05 10:01:46 +00:00
|
|
|
/* Set up everything for writing the commit object. This includes
|
|
|
|
running hooks, writing the trees, and interacting with the user. */
|
2009-08-10 04:59:30 +00:00
|
|
|
if (!prepare_to_commit(index_file, prefix, &s)) {
|
2007-11-18 09:52:55 +00:00
|
|
|
rollback_index_files();
|
2007-11-08 16:59:00 +00:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Determine parents */
|
|
|
|
if (initial_commit) {
|
|
|
|
reflog_msg = "commit (initial)";
|
|
|
|
} else if (amend) {
|
|
|
|
struct commit_list *c;
|
|
|
|
struct commit *commit;
|
|
|
|
|
|
|
|
reflog_msg = "commit (amend)";
|
|
|
|
commit = lookup_commit(head_sha1);
|
|
|
|
if (!commit || parse_commit(commit))
|
|
|
|
die("could not parse HEAD commit");
|
|
|
|
|
|
|
|
for (c = commit->parents; c; c = c->next)
|
2008-09-10 20:10:32 +00:00
|
|
|
pptr = &commit_list_insert(c->item, pptr)->next;
|
2007-11-08 16:59:00 +00:00
|
|
|
} else if (in_merge) {
|
2008-10-09 19:12:12 +00:00
|
|
|
struct strbuf m = STRBUF_INIT;
|
2007-11-08 16:59:00 +00:00
|
|
|
FILE *fp;
|
|
|
|
|
|
|
|
reflog_msg = "commit (merge)";
|
2008-09-10 20:10:32 +00:00
|
|
|
pptr = &commit_list_insert(lookup_commit(head_sha1), pptr)->next;
|
2007-11-08 16:59:00 +00:00
|
|
|
fp = fopen(git_path("MERGE_HEAD"), "r");
|
|
|
|
if (fp == NULL)
|
2009-06-27 15:58:46 +00:00
|
|
|
die_errno("could not open '%s' for reading",
|
|
|
|
git_path("MERGE_HEAD"));
|
2008-01-16 00:12:33 +00:00
|
|
|
while (strbuf_getline(&m, fp, '\n') != EOF) {
|
|
|
|
unsigned char sha1[20];
|
|
|
|
if (get_sha1_hex(m.buf, sha1) < 0)
|
|
|
|
die("Corrupt MERGE_HEAD file (%s)", m.buf);
|
2008-09-10 20:10:32 +00:00
|
|
|
pptr = &commit_list_insert(lookup_commit(sha1), pptr)->next;
|
2008-01-16 00:12:33 +00:00
|
|
|
}
|
2007-11-08 16:59:00 +00:00
|
|
|
fclose(fp);
|
|
|
|
strbuf_release(&m);
|
builtin-commit: use reduce_heads() only when appropriate
Since commit 6bb6b034 (builtin-commit: use commit_tree(), 2008-09-10),
builtin-commit performs a reduce_heads() unconditionally. However,
it's not always needed, and in some cases even harmful.
reduce_heads() is not needed for the initial commit or for an
"ordinary" commit, because they don't have any or have only one
parent, respectively.
reduce_heads() must be avoided when 'git commit' is run after a 'git
merge --no-ff --no-commit', otherwise it will turn the
non-fast-forward merge into fast-forward. For the same reason,
reduce_heads() must be avoided when amending such a merge commit.
To resolve this issue, 'git merge' will write info about whether
fast-forward is allowed or not to $GIT_DIR/MERGE_MODE. Based on this
info, 'git commit' will only perform reduce_heads() when it's
committing a merge and fast-forward is enabled.
Also add test cases to ensure that non-fast-forward merges are
committed and amended properly.
Signed-off-by: Miklos Vajna <vmiklos@frugalware.org>
Signed-off-by: SZEDER Gábor <szeder@ira.uka.de>
Signed-off-by: Shawn O. Pearce <spearce@spearce.org>
2008-10-03 12:04:47 +00:00
|
|
|
if (!stat(git_path("MERGE_MODE"), &statbuf)) {
|
|
|
|
if (strbuf_read_file(&sb, git_path("MERGE_MODE"), 0) < 0)
|
2009-06-27 15:58:46 +00:00
|
|
|
die_errno("could not read MERGE_MODE");
|
builtin-commit: use reduce_heads() only when appropriate
Since commit 6bb6b034 (builtin-commit: use commit_tree(), 2008-09-10),
builtin-commit performs a reduce_heads() unconditionally. However,
it's not always needed, and in some cases even harmful.
reduce_heads() is not needed for the initial commit or for an
"ordinary" commit, because they don't have any or have only one
parent, respectively.
reduce_heads() must be avoided when 'git commit' is run after a 'git
merge --no-ff --no-commit', otherwise it will turn the
non-fast-forward merge into fast-forward. For the same reason,
reduce_heads() must be avoided when amending such a merge commit.
To resolve this issue, 'git merge' will write info about whether
fast-forward is allowed or not to $GIT_DIR/MERGE_MODE. Based on this
info, 'git commit' will only perform reduce_heads() when it's
committing a merge and fast-forward is enabled.
Also add test cases to ensure that non-fast-forward merges are
committed and amended properly.
Signed-off-by: Miklos Vajna <vmiklos@frugalware.org>
Signed-off-by: SZEDER Gábor <szeder@ira.uka.de>
Signed-off-by: Shawn O. Pearce <spearce@spearce.org>
2008-10-03 12:04:47 +00:00
|
|
|
if (!strcmp(sb.buf, "no-ff"))
|
|
|
|
allow_fast_forward = 0;
|
|
|
|
}
|
|
|
|
if (allow_fast_forward)
|
|
|
|
parents = reduce_heads(parents);
|
2007-11-08 16:59:00 +00:00
|
|
|
} else {
|
|
|
|
reflog_msg = "commit";
|
2008-09-10 20:10:32 +00:00
|
|
|
pptr = &commit_list_insert(lookup_commit(head_sha1), pptr)->next;
|
2007-11-08 16:59:00 +00:00
|
|
|
}
|
|
|
|
|
2008-02-05 10:01:46 +00:00
|
|
|
/* Finally, get the commit message */
|
builtin-commit: use reduce_heads() only when appropriate
Since commit 6bb6b034 (builtin-commit: use commit_tree(), 2008-09-10),
builtin-commit performs a reduce_heads() unconditionally. However,
it's not always needed, and in some cases even harmful.
reduce_heads() is not needed for the initial commit or for an
"ordinary" commit, because they don't have any or have only one
parent, respectively.
reduce_heads() must be avoided when 'git commit' is run after a 'git
merge --no-ff --no-commit', otherwise it will turn the
non-fast-forward merge into fast-forward. For the same reason,
reduce_heads() must be avoided when amending such a merge commit.
To resolve this issue, 'git merge' will write info about whether
fast-forward is allowed or not to $GIT_DIR/MERGE_MODE. Based on this
info, 'git commit' will only perform reduce_heads() when it's
committing a merge and fast-forward is enabled.
Also add test cases to ensure that non-fast-forward merges are
committed and amended properly.
Signed-off-by: Miklos Vajna <vmiklos@frugalware.org>
Signed-off-by: SZEDER Gábor <szeder@ira.uka.de>
Signed-off-by: Shawn O. Pearce <spearce@spearce.org>
2008-10-03 12:04:47 +00:00
|
|
|
strbuf_reset(&sb);
|
2007-12-09 07:23:20 +00:00
|
|
|
if (strbuf_read_file(&sb, git_path(commit_editmsg), 0) < 0) {
|
2009-06-27 15:58:47 +00:00
|
|
|
int saved_errno = errno;
|
2007-12-09 07:23:20 +00:00
|
|
|
rollback_index_files();
|
2009-06-27 15:58:47 +00:00
|
|
|
die("could not read commit message: %s", strerror(saved_errno));
|
2007-12-09 07:23:20 +00:00
|
|
|
}
|
2007-11-22 02:54:49 +00:00
|
|
|
|
|
|
|
/* Truncate the message just before the diff, if any. */
|
2008-11-12 08:25:52 +00:00
|
|
|
if (verbose) {
|
|
|
|
p = strstr(sb.buf, "\ndiff --git ");
|
|
|
|
if (p != NULL)
|
|
|
|
strbuf_setlen(&sb, p - sb.buf + 1);
|
|
|
|
}
|
2007-11-22 02:54:49 +00:00
|
|
|
|
2007-12-22 18:46:24 +00:00
|
|
|
if (cleanup_mode != CLEANUP_NONE)
|
|
|
|
stripspace(&sb, cleanup_mode == CLEANUP_ALL);
|
2008-09-10 20:10:32 +00:00
|
|
|
if (message_is_empty(&sb)) {
|
2007-11-18 09:52:55 +00:00
|
|
|
rollback_index_files();
|
2008-07-31 07:36:09 +00:00
|
|
|
fprintf(stderr, "Aborting commit due to empty commit message.\n");
|
|
|
|
exit(1);
|
2007-11-18 09:52:55 +00:00
|
|
|
}
|
2007-11-08 16:59:00 +00:00
|
|
|
|
2008-09-10 20:10:32 +00:00
|
|
|
if (commit_tree(sb.buf, active_cache_tree->sha1, parents, commit_sha1,
|
|
|
|
fmt_ident(author_name, author_email, author_date,
|
|
|
|
IDENT_ERROR_ON_NO_NAME))) {
|
2007-11-18 09:52:55 +00:00
|
|
|
rollback_index_files();
|
2007-11-08 16:59:00 +00:00
|
|
|
die("failed to write commit object");
|
2007-11-18 09:52:55 +00:00
|
|
|
}
|
2007-11-08 16:59:00 +00:00
|
|
|
|
|
|
|
ref_lock = lock_any_ref_for_update("HEAD",
|
|
|
|
initial_commit ? NULL : head_sha1,
|
|
|
|
0);
|
|
|
|
|
2008-09-10 20:10:32 +00:00
|
|
|
nl = strchr(sb.buf, '\n');
|
2007-11-08 12:15:26 +00:00
|
|
|
if (nl)
|
|
|
|
strbuf_setlen(&sb, nl + 1 - sb.buf);
|
|
|
|
else
|
|
|
|
strbuf_addch(&sb, '\n');
|
|
|
|
strbuf_insert(&sb, 0, reflog_msg, strlen(reflog_msg));
|
|
|
|
strbuf_insert(&sb, strlen(reflog_msg), ": ", 2);
|
2007-11-08 16:59:00 +00:00
|
|
|
|
2007-11-18 09:52:55 +00:00
|
|
|
if (!ref_lock) {
|
|
|
|
rollback_index_files();
|
2007-11-08 16:59:00 +00:00
|
|
|
die("cannot lock HEAD ref");
|
2007-11-18 09:52:55 +00:00
|
|
|
}
|
|
|
|
if (write_ref_sha1(ref_lock, commit_sha1, sb.buf) < 0) {
|
|
|
|
rollback_index_files();
|
2007-11-08 16:59:00 +00:00
|
|
|
die("cannot update HEAD ref");
|
2007-11-18 09:52:55 +00:00
|
|
|
}
|
2007-11-08 16:59:00 +00:00
|
|
|
|
|
|
|
unlink(git_path("MERGE_HEAD"));
|
|
|
|
unlink(git_path("MERGE_MSG"));
|
builtin-commit: use reduce_heads() only when appropriate
Since commit 6bb6b034 (builtin-commit: use commit_tree(), 2008-09-10),
builtin-commit performs a reduce_heads() unconditionally. However,
it's not always needed, and in some cases even harmful.
reduce_heads() is not needed for the initial commit or for an
"ordinary" commit, because they don't have any or have only one
parent, respectively.
reduce_heads() must be avoided when 'git commit' is run after a 'git
merge --no-ff --no-commit', otherwise it will turn the
non-fast-forward merge into fast-forward. For the same reason,
reduce_heads() must be avoided when amending such a merge commit.
To resolve this issue, 'git merge' will write info about whether
fast-forward is allowed or not to $GIT_DIR/MERGE_MODE. Based on this
info, 'git commit' will only perform reduce_heads() when it's
committing a merge and fast-forward is enabled.
Also add test cases to ensure that non-fast-forward merges are
committed and amended properly.
Signed-off-by: Miklos Vajna <vmiklos@frugalware.org>
Signed-off-by: SZEDER Gábor <szeder@ira.uka.de>
Signed-off-by: Shawn O. Pearce <spearce@spearce.org>
2008-10-03 12:04:47 +00:00
|
|
|
unlink(git_path("MERGE_MODE"));
|
2008-02-08 09:53:58 +00:00
|
|
|
unlink(git_path("SQUASH_MSG"));
|
2007-11-08 16:59:00 +00:00
|
|
|
|
2008-01-23 17:21:22 +00:00
|
|
|
if (commit_index_files())
|
|
|
|
die ("Repository has been updated, but unable to write\n"
|
|
|
|
"new_index file. Check that disk is not full or quota is\n"
|
|
|
|
"not exceeded, and then \"git reset HEAD\" to recover.");
|
2007-11-08 16:59:00 +00:00
|
|
|
|
2009-12-04 08:20:48 +00:00
|
|
|
rerere(0);
|
2007-11-18 09:52:55 +00:00
|
|
|
run_hook(get_index_file(), "post-commit", NULL);
|
2010-03-12 17:04:28 +00:00
|
|
|
if (amend && !no_post_rewrite) {
|
2010-03-12 17:04:34 +00:00
|
|
|
struct notes_rewrite_cfg *cfg;
|
|
|
|
cfg = init_copy_notes_for_rewrite("amend");
|
|
|
|
if (cfg) {
|
|
|
|
copy_note_for_rewrite(cfg, head_sha1, commit_sha1);
|
|
|
|
finish_copy_notes_for_rewrite(cfg);
|
|
|
|
}
|
2010-03-12 17:04:28 +00:00
|
|
|
run_rewrite_hook(head_sha1, commit_sha1);
|
|
|
|
}
|
2007-11-08 16:59:00 +00:00
|
|
|
if (!quiet)
|
|
|
|
print_summary(prefix, commit_sha1);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|