2006-04-21 17:27:34 +00:00
|
|
|
/*
|
|
|
|
* Builtin "git log" and related commands (show, whatchanged)
|
|
|
|
*
|
|
|
|
* (C) Copyright 2006 Linus Torvalds
|
|
|
|
* 2006 Junio Hamano
|
|
|
|
*/
|
|
|
|
#include "cache.h"
|
2015-06-22 14:03:05 +00:00
|
|
|
#include "refs.h"
|
2008-02-18 07:26:03 +00:00
|
|
|
#include "color.h"
|
2006-04-21 17:27:34 +00:00
|
|
|
#include "commit.h"
|
|
|
|
#include "diff.h"
|
|
|
|
#include "revision.h"
|
|
|
|
#include "log-tree.h"
|
2006-04-21 20:19:58 +00:00
|
|
|
#include "builtin.h"
|
2006-12-14 10:31:05 +00:00
|
|
|
#include "tag.h"
|
2007-02-08 17:51:56 +00:00
|
|
|
#include "reflog-walk.h"
|
2007-04-10 00:01:27 +00:00
|
|
|
#include "patch-ids.h"
|
2008-02-19 03:56:13 +00:00
|
|
|
#include "run-command.h"
|
2008-02-25 23:24:17 +00:00
|
|
|
#include "shortlog.h"
|
2008-12-29 17:45:20 +00:00
|
|
|
#include "remote.h"
|
2009-02-19 21:26:31 +00:00
|
|
|
#include "string-list.h"
|
2009-05-16 09:24:46 +00:00
|
|
|
#include "parse-options.h"
|
Implement line-history search (git log -L)
This is a rewrite of much of Bo's work, mainly in an effort to split
it into smaller, easier to understand routines.
The algorithm is built around the struct range_set, which encodes a
series of line ranges as intervals [a,b). This is used in two
contexts:
* A set of lines we are tracking (which will change as we dig through
history).
* To encode diffs, as pairs of ranges.
The main routine is range_set_map_across_diff(). It processes the
diff between a commit C and some parent P. It determines which diff
hunks are relevant to the ranges tracked in C, and computes the new
ranges for P.
The algorithm is then simply to process history in topological order
from newest to oldest, computing ranges and (partial) diffs. At
branch points, we need to merge the ranges we are watching. We will
find that many commits do not affect the chosen ranges, and mark them
TREESAME (in addition to those already filtered by pathspec limiting).
Another pass of history simplification then gets rid of such commits.
This is wired as an extra filtering pass in the log machinery. This
currently only reduces code duplication, but should allow for other
simplifications and options to be used.
Finally, we hook a diff printer into the output chain. Ideally we
would wire directly into the diff logic, to optionally use features
like word diff. However, that will require some major reworking of
the diff chain, so we completely replace the output with our own diff
for now.
As this was a GSoC project, and has quite some history by now, many
people have helped. In no particular order, thanks go to
Jakub Narebski <jnareb@gmail.com>
Jens Lehmann <Jens.Lehmann@web.de>
Jonathan Nieder <jrnieder@gmail.com>
Junio C Hamano <gitster@pobox.com>
Ramsay Jones <ramsay@ramsay1.demon.co.uk>
Will Palmer <wmpalmer@gmail.com>
Apologies to everyone I forgot.
Signed-off-by: Bo Yang <struggleyb.nku@gmail.com>
Signed-off-by: Thomas Rast <trast@student.ethz.ch>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-03-28 16:47:32 +00:00
|
|
|
#include "line-log.h"
|
2011-09-22 03:32:28 +00:00
|
|
|
#include "branch.h"
|
2012-03-07 10:54:19 +00:00
|
|
|
#include "streaming.h"
|
2012-06-02 18:51:42 +00:00
|
|
|
#include "version.h"
|
2013-01-05 21:26:43 +00:00
|
|
|
#include "mailmap.h"
|
2013-03-27 15:13:39 +00:00
|
|
|
#include "gpg-interface.h"
|
2006-04-21 17:27:34 +00:00
|
|
|
|
2008-05-22 15:24:07 +00:00
|
|
|
/* Set a default date-time format for git log ("log.date" config variable) */
|
|
|
|
static const char *default_date_mode = NULL;
|
|
|
|
|
2011-05-18 17:56:04 +00:00
|
|
|
static int default_abbrev_commit;
|
2006-11-23 09:36:33 +00:00
|
|
|
static int default_show_root = 1;
|
2015-07-08 01:29:34 +00:00
|
|
|
static int default_follow;
|
2016-06-22 16:51:26 +00:00
|
|
|
static int default_show_signature;
|
2010-02-17 18:20:49 +00:00
|
|
|
static int decoration_style;
|
2011-04-14 14:28:30 +00:00
|
|
|
static int decoration_given;
|
2013-01-05 21:26:46 +00:00
|
|
|
static int use_mailmap_config;
|
2007-07-04 10:37:27 +00:00
|
|
|
static const char *fmt_patch_subject_prefix = "PATCH";
|
2008-03-02 09:05:53 +00:00
|
|
|
static const char *fmt_pretty;
|
2006-11-23 09:36:33 +00:00
|
|
|
|
2011-04-14 14:28:30 +00:00
|
|
|
static const char * const builtin_log_usage[] = {
|
2015-04-02 21:26:56 +00:00
|
|
|
N_("git log [<options>] [<revision-range>] [[--] <path>...]"),
|
2015-02-11 21:44:19 +00:00
|
|
|
N_("git show [<options>] <object>..."),
|
2011-04-14 14:28:30 +00:00
|
|
|
NULL
|
|
|
|
};
|
2009-08-06 10:47:21 +00:00
|
|
|
|
Implement line-history search (git log -L)
This is a rewrite of much of Bo's work, mainly in an effort to split
it into smaller, easier to understand routines.
The algorithm is built around the struct range_set, which encodes a
series of line ranges as intervals [a,b). This is used in two
contexts:
* A set of lines we are tracking (which will change as we dig through
history).
* To encode diffs, as pairs of ranges.
The main routine is range_set_map_across_diff(). It processes the
diff between a commit C and some parent P. It determines which diff
hunks are relevant to the ranges tracked in C, and computes the new
ranges for P.
The algorithm is then simply to process history in topological order
from newest to oldest, computing ranges and (partial) diffs. At
branch points, we need to merge the ranges we are watching. We will
find that many commits do not affect the chosen ranges, and mark them
TREESAME (in addition to those already filtered by pathspec limiting).
Another pass of history simplification then gets rid of such commits.
This is wired as an extra filtering pass in the log machinery. This
currently only reduces code duplication, but should allow for other
simplifications and options to be used.
Finally, we hook a diff printer into the output chain. Ideally we
would wire directly into the diff logic, to optionally use features
like word diff. However, that will require some major reworking of
the diff chain, so we completely replace the output with our own diff
for now.
As this was a GSoC project, and has quite some history by now, many
people have helped. In no particular order, thanks go to
Jakub Narebski <jnareb@gmail.com>
Jens Lehmann <Jens.Lehmann@web.de>
Jonathan Nieder <jrnieder@gmail.com>
Junio C Hamano <gitster@pobox.com>
Ramsay Jones <ramsay@ramsay1.demon.co.uk>
Will Palmer <wmpalmer@gmail.com>
Apologies to everyone I forgot.
Signed-off-by: Bo Yang <struggleyb.nku@gmail.com>
Signed-off-by: Thomas Rast <trast@student.ethz.ch>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-03-28 16:47:32 +00:00
|
|
|
struct line_opt_callback_data {
|
|
|
|
struct rev_info *rev;
|
|
|
|
const char *prefix;
|
|
|
|
struct string_list args;
|
|
|
|
};
|
|
|
|
|
2010-02-17 18:20:49 +00:00
|
|
|
static int parse_decoration_style(const char *var, const char *value)
|
|
|
|
{
|
|
|
|
switch (git_config_maybe_bool(var, value)) {
|
|
|
|
case 1:
|
|
|
|
return DECORATE_SHORT_REFS;
|
|
|
|
case 0:
|
|
|
|
return 0;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (!strcmp(value, "full"))
|
|
|
|
return DECORATE_FULL_REFS;
|
|
|
|
else if (!strcmp(value, "short"))
|
|
|
|
return DECORATE_SHORT_REFS;
|
2014-05-29 22:19:40 +00:00
|
|
|
else if (!strcmp(value, "auto"))
|
|
|
|
return (isatty(1) || pager_in_use()) ? DECORATE_SHORT_REFS : 0;
|
2010-02-17 18:20:49 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2011-04-14 14:28:30 +00:00
|
|
|
static int decorate_callback(const struct option *opt, const char *arg, int unset)
|
|
|
|
{
|
|
|
|
if (unset)
|
|
|
|
decoration_style = 0;
|
|
|
|
else if (arg)
|
|
|
|
decoration_style = parse_decoration_style("command line", arg);
|
|
|
|
else
|
|
|
|
decoration_style = DECORATE_SHORT_REFS;
|
|
|
|
|
|
|
|
if (decoration_style < 0)
|
2014-09-14 22:07:10 +00:00
|
|
|
die(_("invalid --decorate option: %s"), arg);
|
2011-04-14 14:28:30 +00:00
|
|
|
|
|
|
|
decoration_given = 1;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
Implement line-history search (git log -L)
This is a rewrite of much of Bo's work, mainly in an effort to split
it into smaller, easier to understand routines.
The algorithm is built around the struct range_set, which encodes a
series of line ranges as intervals [a,b). This is used in two
contexts:
* A set of lines we are tracking (which will change as we dig through
history).
* To encode diffs, as pairs of ranges.
The main routine is range_set_map_across_diff(). It processes the
diff between a commit C and some parent P. It determines which diff
hunks are relevant to the ranges tracked in C, and computes the new
ranges for P.
The algorithm is then simply to process history in topological order
from newest to oldest, computing ranges and (partial) diffs. At
branch points, we need to merge the ranges we are watching. We will
find that many commits do not affect the chosen ranges, and mark them
TREESAME (in addition to those already filtered by pathspec limiting).
Another pass of history simplification then gets rid of such commits.
This is wired as an extra filtering pass in the log machinery. This
currently only reduces code duplication, but should allow for other
simplifications and options to be used.
Finally, we hook a diff printer into the output chain. Ideally we
would wire directly into the diff logic, to optionally use features
like word diff. However, that will require some major reworking of
the diff chain, so we completely replace the output with our own diff
for now.
As this was a GSoC project, and has quite some history by now, many
people have helped. In no particular order, thanks go to
Jakub Narebski <jnareb@gmail.com>
Jens Lehmann <Jens.Lehmann@web.de>
Jonathan Nieder <jrnieder@gmail.com>
Junio C Hamano <gitster@pobox.com>
Ramsay Jones <ramsay@ramsay1.demon.co.uk>
Will Palmer <wmpalmer@gmail.com>
Apologies to everyone I forgot.
Signed-off-by: Bo Yang <struggleyb.nku@gmail.com>
Signed-off-by: Thomas Rast <trast@student.ethz.ch>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-03-28 16:47:32 +00:00
|
|
|
static int log_line_range_callback(const struct option *option, const char *arg, int unset)
|
|
|
|
{
|
|
|
|
struct line_opt_callback_data *data = option->value;
|
|
|
|
|
|
|
|
if (!arg)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
data->rev->line_level_traverse = 1;
|
|
|
|
string_list_append(&data->args, arg);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2016-02-25 08:59:20 +00:00
|
|
|
static void init_log_defaults(void)
|
|
|
|
{
|
|
|
|
init_grep_defaults();
|
2016-02-25 08:59:21 +00:00
|
|
|
init_diff_ui_defaults();
|
2016-02-25 08:59:20 +00:00
|
|
|
}
|
|
|
|
|
2011-04-01 09:20:31 +00:00
|
|
|
static void cmd_log_init_defaults(struct rev_info *rev)
|
2006-04-21 17:27:34 +00:00
|
|
|
{
|
2008-03-02 09:05:53 +00:00
|
|
|
if (fmt_pretty)
|
2008-04-08 00:11:34 +00:00
|
|
|
get_commit_format(fmt_pretty, rev);
|
2015-07-08 01:29:34 +00:00
|
|
|
if (default_follow)
|
|
|
|
DIFF_OPT_SET(&rev->diffopt, DEFAULT_FOLLOW_RENAMES);
|
2006-04-21 17:27:34 +00:00
|
|
|
rev->verbose_header = 1;
|
2007-11-10 19:05:14 +00:00
|
|
|
DIFF_OPT_SET(&rev->diffopt, RECURSIVE);
|
2012-03-01 12:26:41 +00:00
|
|
|
rev->diffopt.stat_width = -1; /* use full terminal width */
|
2012-03-01 12:26:46 +00:00
|
|
|
rev->diffopt.stat_graph_width = -1; /* respect statGraphWidth config */
|
2011-05-18 17:56:04 +00:00
|
|
|
rev->abbrev_commit = default_abbrev_commit;
|
2006-11-23 09:36:33 +00:00
|
|
|
rev->show_root_diff = default_show_root;
|
2007-07-04 10:37:27 +00:00
|
|
|
rev->subject_prefix = fmt_patch_subject_prefix;
|
2016-06-22 16:51:26 +00:00
|
|
|
rev->show_signature = default_show_signature;
|
2008-12-08 02:54:17 +00:00
|
|
|
DIFF_OPT_SET(&rev->diffopt, ALLOW_TEXTCONV);
|
2008-05-22 15:24:07 +00:00
|
|
|
|
|
|
|
if (default_date_mode)
|
convert "enum date_mode" into a struct
In preparation for adding date modes that may carry extra
information beyond the mode itself, this patch converts the
date_mode enum into a struct.
Most of the conversion is fairly straightforward; we pass
the struct as a pointer and dereference the type field where
necessary. Locations that declare a date_mode can use a "{}"
constructor. However, the tricky case is where we use the
enum labels as constants, like:
show_date(t, tz, DATE_NORMAL);
Ideally we could say:
show_date(t, tz, &{ DATE_NORMAL });
but of course C does not allow that. Likewise, we cannot
cast the constant to a struct, because we need to pass an
actual address. Our options are basically:
1. Manually add a "struct date_mode d = { DATE_NORMAL }"
definition to each caller, and pass "&d". This makes
the callers uglier, because they sometimes do not even
have their own scope (e.g., they are inside a switch
statement).
2. Provide a pre-made global "date_normal" struct that can
be passed by address. We'd also need "date_rfc2822",
"date_iso8601", and so forth. But at least the ugliness
is defined in one place.
3. Provide a wrapper that generates the correct struct on
the fly. The big downside is that we end up pointing to
a single global, which makes our wrapper non-reentrant.
But show_date is already not reentrant, so it does not
matter.
This patch implements 3, along with a minor macro to keep
the size of the callers sane.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2015-06-25 16:55:02 +00:00
|
|
|
parse_date_format(default_date_mode, &rev->date_mode);
|
2013-05-10 15:10:11 +00:00
|
|
|
rev->diffopt.touched_flags = 0;
|
2011-04-01 09:20:31 +00:00
|
|
|
}
|
2008-05-22 15:24:07 +00:00
|
|
|
|
2011-04-01 09:20:31 +00:00
|
|
|
static void cmd_log_init_finish(int argc, const char **argv, const char *prefix,
|
|
|
|
struct rev_info *rev, struct setup_revision_opt *opt)
|
|
|
|
{
|
|
|
|
struct userformat_want w;
|
2013-01-05 21:26:43 +00:00
|
|
|
int quiet = 0, source = 0, mailmap = 0;
|
Implement line-history search (git log -L)
This is a rewrite of much of Bo's work, mainly in an effort to split
it into smaller, easier to understand routines.
The algorithm is built around the struct range_set, which encodes a
series of line ranges as intervals [a,b). This is used in two
contexts:
* A set of lines we are tracking (which will change as we dig through
history).
* To encode diffs, as pairs of ranges.
The main routine is range_set_map_across_diff(). It processes the
diff between a commit C and some parent P. It determines which diff
hunks are relevant to the ranges tracked in C, and computes the new
ranges for P.
The algorithm is then simply to process history in topological order
from newest to oldest, computing ranges and (partial) diffs. At
branch points, we need to merge the ranges we are watching. We will
find that many commits do not affect the chosen ranges, and mark them
TREESAME (in addition to those already filtered by pathspec limiting).
Another pass of history simplification then gets rid of such commits.
This is wired as an extra filtering pass in the log machinery. This
currently only reduces code duplication, but should allow for other
simplifications and options to be used.
Finally, we hook a diff printer into the output chain. Ideally we
would wire directly into the diff logic, to optionally use features
like word diff. However, that will require some major reworking of
the diff chain, so we completely replace the output with our own diff
for now.
As this was a GSoC project, and has quite some history by now, many
people have helped. In no particular order, thanks go to
Jakub Narebski <jnareb@gmail.com>
Jens Lehmann <Jens.Lehmann@web.de>
Jonathan Nieder <jrnieder@gmail.com>
Junio C Hamano <gitster@pobox.com>
Ramsay Jones <ramsay@ramsay1.demon.co.uk>
Will Palmer <wmpalmer@gmail.com>
Apologies to everyone I forgot.
Signed-off-by: Bo Yang <struggleyb.nku@gmail.com>
Signed-off-by: Thomas Rast <trast@student.ethz.ch>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-03-28 16:47:32 +00:00
|
|
|
static struct line_opt_callback_data line_cb = {NULL, NULL, STRING_LIST_INIT_DUP};
|
2011-04-14 14:28:30 +00:00
|
|
|
|
|
|
|
const struct option builtin_log_options[] = {
|
2013-08-03 11:51:20 +00:00
|
|
|
OPT__QUIET(&quiet, N_("suppress diff output")),
|
2013-04-07 17:46:22 +00:00
|
|
|
OPT_BOOL(0, "source", &source, N_("show source")),
|
|
|
|
OPT_BOOL(0, "use-mailmap", &mailmap, N_("Use mail map file")),
|
2012-08-20 12:32:19 +00:00
|
|
|
{ OPTION_CALLBACK, 0, "decorate", NULL, NULL, N_("decorate options"),
|
2011-04-14 14:28:30 +00:00
|
|
|
PARSE_OPT_OPTARG, decorate_callback},
|
Implement line-history search (git log -L)
This is a rewrite of much of Bo's work, mainly in an effort to split
it into smaller, easier to understand routines.
The algorithm is built around the struct range_set, which encodes a
series of line ranges as intervals [a,b). This is used in two
contexts:
* A set of lines we are tracking (which will change as we dig through
history).
* To encode diffs, as pairs of ranges.
The main routine is range_set_map_across_diff(). It processes the
diff between a commit C and some parent P. It determines which diff
hunks are relevant to the ranges tracked in C, and computes the new
ranges for P.
The algorithm is then simply to process history in topological order
from newest to oldest, computing ranges and (partial) diffs. At
branch points, we need to merge the ranges we are watching. We will
find that many commits do not affect the chosen ranges, and mark them
TREESAME (in addition to those already filtered by pathspec limiting).
Another pass of history simplification then gets rid of such commits.
This is wired as an extra filtering pass in the log machinery. This
currently only reduces code duplication, but should allow for other
simplifications and options to be used.
Finally, we hook a diff printer into the output chain. Ideally we
would wire directly into the diff logic, to optionally use features
like word diff. However, that will require some major reworking of
the diff chain, so we completely replace the output with our own diff
for now.
As this was a GSoC project, and has quite some history by now, many
people have helped. In no particular order, thanks go to
Jakub Narebski <jnareb@gmail.com>
Jens Lehmann <Jens.Lehmann@web.de>
Jonathan Nieder <jrnieder@gmail.com>
Junio C Hamano <gitster@pobox.com>
Ramsay Jones <ramsay@ramsay1.demon.co.uk>
Will Palmer <wmpalmer@gmail.com>
Apologies to everyone I forgot.
Signed-off-by: Bo Yang <struggleyb.nku@gmail.com>
Signed-off-by: Thomas Rast <trast@student.ethz.ch>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-03-28 16:47:32 +00:00
|
|
|
OPT_CALLBACK('L', NULL, &line_cb, "n,m:file",
|
2014-09-14 22:07:10 +00:00
|
|
|
N_("Process line range n,m in file, counting from 1"),
|
Implement line-history search (git log -L)
This is a rewrite of much of Bo's work, mainly in an effort to split
it into smaller, easier to understand routines.
The algorithm is built around the struct range_set, which encodes a
series of line ranges as intervals [a,b). This is used in two
contexts:
* A set of lines we are tracking (which will change as we dig through
history).
* To encode diffs, as pairs of ranges.
The main routine is range_set_map_across_diff(). It processes the
diff between a commit C and some parent P. It determines which diff
hunks are relevant to the ranges tracked in C, and computes the new
ranges for P.
The algorithm is then simply to process history in topological order
from newest to oldest, computing ranges and (partial) diffs. At
branch points, we need to merge the ranges we are watching. We will
find that many commits do not affect the chosen ranges, and mark them
TREESAME (in addition to those already filtered by pathspec limiting).
Another pass of history simplification then gets rid of such commits.
This is wired as an extra filtering pass in the log machinery. This
currently only reduces code duplication, but should allow for other
simplifications and options to be used.
Finally, we hook a diff printer into the output chain. Ideally we
would wire directly into the diff logic, to optionally use features
like word diff. However, that will require some major reworking of
the diff chain, so we completely replace the output with our own diff
for now.
As this was a GSoC project, and has quite some history by now, many
people have helped. In no particular order, thanks go to
Jakub Narebski <jnareb@gmail.com>
Jens Lehmann <Jens.Lehmann@web.de>
Jonathan Nieder <jrnieder@gmail.com>
Junio C Hamano <gitster@pobox.com>
Ramsay Jones <ramsay@ramsay1.demon.co.uk>
Will Palmer <wmpalmer@gmail.com>
Apologies to everyone I forgot.
Signed-off-by: Bo Yang <struggleyb.nku@gmail.com>
Signed-off-by: Thomas Rast <trast@student.ethz.ch>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-03-28 16:47:32 +00:00
|
|
|
log_line_range_callback),
|
2011-04-14 14:28:30 +00:00
|
|
|
OPT_END()
|
|
|
|
};
|
|
|
|
|
Implement line-history search (git log -L)
This is a rewrite of much of Bo's work, mainly in an effort to split
it into smaller, easier to understand routines.
The algorithm is built around the struct range_set, which encodes a
series of line ranges as intervals [a,b). This is used in two
contexts:
* A set of lines we are tracking (which will change as we dig through
history).
* To encode diffs, as pairs of ranges.
The main routine is range_set_map_across_diff(). It processes the
diff between a commit C and some parent P. It determines which diff
hunks are relevant to the ranges tracked in C, and computes the new
ranges for P.
The algorithm is then simply to process history in topological order
from newest to oldest, computing ranges and (partial) diffs. At
branch points, we need to merge the ranges we are watching. We will
find that many commits do not affect the chosen ranges, and mark them
TREESAME (in addition to those already filtered by pathspec limiting).
Another pass of history simplification then gets rid of such commits.
This is wired as an extra filtering pass in the log machinery. This
currently only reduces code duplication, but should allow for other
simplifications and options to be used.
Finally, we hook a diff printer into the output chain. Ideally we
would wire directly into the diff logic, to optionally use features
like word diff. However, that will require some major reworking of
the diff chain, so we completely replace the output with our own diff
for now.
As this was a GSoC project, and has quite some history by now, many
people have helped. In no particular order, thanks go to
Jakub Narebski <jnareb@gmail.com>
Jens Lehmann <Jens.Lehmann@web.de>
Jonathan Nieder <jrnieder@gmail.com>
Junio C Hamano <gitster@pobox.com>
Ramsay Jones <ramsay@ramsay1.demon.co.uk>
Will Palmer <wmpalmer@gmail.com>
Apologies to everyone I forgot.
Signed-off-by: Bo Yang <struggleyb.nku@gmail.com>
Signed-off-by: Thomas Rast <trast@student.ethz.ch>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-03-28 16:47:32 +00:00
|
|
|
line_cb.rev = rev;
|
|
|
|
line_cb.prefix = prefix;
|
|
|
|
|
2013-01-05 21:26:46 +00:00
|
|
|
mailmap = use_mailmap_config;
|
2011-04-14 14:28:30 +00:00
|
|
|
argc = parse_options(argc, argv, prefix,
|
|
|
|
builtin_log_options, builtin_log_usage,
|
|
|
|
PARSE_OPT_KEEP_ARGV0 | PARSE_OPT_KEEP_UNKNOWN |
|
|
|
|
PARSE_OPT_KEEP_DASHDASH);
|
2006-12-25 19:48:35 +00:00
|
|
|
|
2011-05-28 19:25:24 +00:00
|
|
|
if (quiet)
|
|
|
|
rev->diffopt.output_format |= DIFF_FORMAT_NO_OUTPUT;
|
log: fix --quiet synonym for -s
Originally the "--quiet" option was parsed by the
diff-option parser into the internal QUICK option. This had
the effect of silencing diff output from the log (which was
not intended, but happened to work and people started to
use it). But it also had other odd side effects at the diff
level (for example, it would suppress the second commit in
"git show A B").
To fix this, commit 1c40c36 converted log to parse-options
and handled the "quiet" option separately, not passing it
on to the diff code. However, it simply ignored the option,
which was a regression for people using it as a synonym for
"-s". Commit 01771a8 then fixed that by interpreting the
option to add DIFF_FORMAT_NO_OUTPUT to the list of output
formats.
However, that commit did not fix it in all cases. It sets
the flag after setup_revisions is called. Naively, this
makes sense because you would expect the setup_revisions
parser to overwrite our output format flag if "-p" or
another output format flag is seen.
However, that is not how the NO_OUTPUT flag works. We
actually store it in the bit-field as just another format.
At the end of setup_revisions, we call diff_setup_done,
which post-processes the bitfield and clears any other
formats if we have set NO_OUTPUT. By setting the flag after
setup_revisions is done, diff_setup_done does not have a
chance to make this tweak, and we end up with other format
options still set.
As a result, the flag would have no effect in "git log -p
--quiet" or "git show --quiet". Fix it by setting the
format flag before the call to setup_revisions.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2012-08-28 21:29:34 +00:00
|
|
|
argc = setup_revisions(argc, argv, rev, opt);
|
2008-05-22 15:24:07 +00:00
|
|
|
|
2011-04-14 14:28:30 +00:00
|
|
|
/* Any arguments at this point are not recognized */
|
|
|
|
if (argc > 1)
|
2014-09-14 22:07:10 +00:00
|
|
|
die(_("unrecognized argument: %s"), argv[1]);
|
2011-04-14 14:28:30 +00:00
|
|
|
|
2010-04-13 20:31:12 +00:00
|
|
|
memset(&w, 0, sizeof(w));
|
|
|
|
userformat_find_requirements(NULL, &w);
|
|
|
|
|
|
|
|
if (!rev->show_notes_given && (!rev->pretty_given || w.notes))
|
2010-01-20 21:59:36 +00:00
|
|
|
rev->show_notes = 1;
|
2010-03-12 17:04:26 +00:00
|
|
|
if (rev->show_notes)
|
|
|
|
init_display_notes(&rev->notes_opt);
|
2010-01-20 21:59:36 +00:00
|
|
|
|
2014-05-20 06:49:20 +00:00
|
|
|
if (rev->diffopt.pickaxe || rev->diffopt.filter ||
|
|
|
|
DIFF_OPT_TST(&rev->diffopt, FOLLOW_RENAMES))
|
2006-06-25 12:39:35 +00:00
|
|
|
rev->always_show_header = 0;
|
2011-04-14 14:28:30 +00:00
|
|
|
|
|
|
|
if (source)
|
|
|
|
rev->show_source = 1;
|
2010-04-06 21:48:55 +00:00
|
|
|
|
2013-01-05 21:26:43 +00:00
|
|
|
if (mailmap) {
|
|
|
|
rev->mailmap = xcalloc(1, sizeof(struct string_list));
|
|
|
|
read_mailmap(rev->mailmap, NULL);
|
|
|
|
}
|
|
|
|
|
2011-05-18 17:56:04 +00:00
|
|
|
if (rev->pretty_given && rev->commit_format == CMIT_FMT_RAW) {
|
|
|
|
/*
|
|
|
|
* "log --pretty=raw" is special; ignore UI oriented
|
|
|
|
* configuration variables such as decoration.
|
|
|
|
*/
|
|
|
|
if (!decoration_given)
|
|
|
|
decoration_style = 0;
|
|
|
|
if (!rev->abbrev_commit_given)
|
|
|
|
rev->abbrev_commit = 0;
|
|
|
|
}
|
2010-04-06 21:48:55 +00:00
|
|
|
|
2009-08-15 14:23:12 +00:00
|
|
|
if (decoration_style) {
|
|
|
|
rev->show_decorations = 1;
|
|
|
|
load_ref_decorations(decoration_style);
|
|
|
|
}
|
Implement line-history search (git log -L)
This is a rewrite of much of Bo's work, mainly in an effort to split
it into smaller, easier to understand routines.
The algorithm is built around the struct range_set, which encodes a
series of line ranges as intervals [a,b). This is used in two
contexts:
* A set of lines we are tracking (which will change as we dig through
history).
* To encode diffs, as pairs of ranges.
The main routine is range_set_map_across_diff(). It processes the
diff between a commit C and some parent P. It determines which diff
hunks are relevant to the ranges tracked in C, and computes the new
ranges for P.
The algorithm is then simply to process history in topological order
from newest to oldest, computing ranges and (partial) diffs. At
branch points, we need to merge the ranges we are watching. We will
find that many commits do not affect the chosen ranges, and mark them
TREESAME (in addition to those already filtered by pathspec limiting).
Another pass of history simplification then gets rid of such commits.
This is wired as an extra filtering pass in the log machinery. This
currently only reduces code duplication, but should allow for other
simplifications and options to be used.
Finally, we hook a diff printer into the output chain. Ideally we
would wire directly into the diff logic, to optionally use features
like word diff. However, that will require some major reworking of
the diff chain, so we completely replace the output with our own diff
for now.
As this was a GSoC project, and has quite some history by now, many
people have helped. In no particular order, thanks go to
Jakub Narebski <jnareb@gmail.com>
Jens Lehmann <Jens.Lehmann@web.de>
Jonathan Nieder <jrnieder@gmail.com>
Junio C Hamano <gitster@pobox.com>
Ramsay Jones <ramsay@ramsay1.demon.co.uk>
Will Palmer <wmpalmer@gmail.com>
Apologies to everyone I forgot.
Signed-off-by: Bo Yang <struggleyb.nku@gmail.com>
Signed-off-by: Thomas Rast <trast@student.ethz.ch>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-03-28 16:47:32 +00:00
|
|
|
|
|
|
|
if (rev->line_level_traverse)
|
|
|
|
line_log_init(rev, line_cb.prefix, &line_cb.args);
|
|
|
|
|
2010-08-24 17:33:59 +00:00
|
|
|
setup_pager();
|
2006-06-25 12:39:35 +00:00
|
|
|
}
|
|
|
|
|
2011-04-01 09:20:31 +00:00
|
|
|
static void cmd_log_init(int argc, const char **argv, const char *prefix,
|
|
|
|
struct rev_info *rev, struct setup_revision_opt *opt)
|
|
|
|
{
|
|
|
|
cmd_log_init_defaults(rev);
|
|
|
|
cmd_log_init_finish(argc, argv, prefix, rev, opt);
|
|
|
|
}
|
|
|
|
|
2007-11-04 20:12:05 +00:00
|
|
|
/*
|
|
|
|
* This gives a rough estimate for how many commits we
|
|
|
|
* will print out in the list.
|
|
|
|
*/
|
|
|
|
static int estimate_commit_count(struct rev_info *rev, struct commit_list *list)
|
|
|
|
{
|
|
|
|
int n = 0;
|
|
|
|
|
|
|
|
while (list) {
|
|
|
|
struct commit *commit = list->item;
|
|
|
|
unsigned int flags = commit->object.flags;
|
|
|
|
list = list->next;
|
2007-11-13 07:16:08 +00:00
|
|
|
if (!(flags & (TREESAME | UNINTERESTING)))
|
2007-11-05 21:22:34 +00:00
|
|
|
n++;
|
2007-11-04 20:12:05 +00:00
|
|
|
}
|
|
|
|
return n;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void show_early_header(struct rev_info *rev, const char *stage, int nr)
|
|
|
|
{
|
|
|
|
if (rev->shown_one) {
|
|
|
|
rev->shown_one = 0;
|
|
|
|
if (rev->commit_format != CMIT_FMT_ONELINE)
|
|
|
|
putchar(rev->diffopt.line_termination);
|
|
|
|
}
|
2016-06-22 15:01:59 +00:00
|
|
|
fprintf(rev->diffopt.file, _("Final output: %d %s\n"), nr, stage);
|
2007-11-04 20:12:05 +00:00
|
|
|
}
|
|
|
|
|
2009-06-18 17:28:43 +00:00
|
|
|
static struct itimerval early_output_timer;
|
2007-11-04 20:12:05 +00:00
|
|
|
|
2007-11-03 18:11:10 +00:00
|
|
|
static void log_show_early(struct rev_info *revs, struct commit_list *list)
|
|
|
|
{
|
2016-06-22 15:01:28 +00:00
|
|
|
int i = revs->early_output, close_file = revs->diffopt.close_file;
|
2007-11-04 20:12:05 +00:00
|
|
|
int show_header = 1;
|
2007-11-03 18:11:10 +00:00
|
|
|
|
2016-06-22 15:01:28 +00:00
|
|
|
revs->diffopt.close_file = 0;
|
toposort: rename "lifo" field
The primary invariant of sort_in_topological_order() is that a
parent commit is not emitted until all children of it are. When
traversing a forked history like this with "git log C E":
A----B----C
\
D----E
we ensure that A is emitted after all of B, C, D, and E are done, B
has to wait until C is done, and D has to wait until E is done.
In some applications, however, we would further want to control how
these child commits B, C, D and E on two parallel ancestry chains
are shown.
Most of the time, we would want to see C and B emitted together, and
then E and D, and finally A (i.e. the --topo-order output). The
"lifo" parameter of the sort_in_topological_order() function is used
to control this behaviour. We start the traversal by knowing two
commits, C and E. While keeping in mind that we also need to
inspect E later, we pick C first to inspect, and we notice and
record that B needs to be inspected. By structuring the "work to be
done" set as a LIFO stack, we ensure that B is inspected next,
before other in-flight commits we had known that we will need to
inspect, e.g. E.
When showing in --date-order, we would want to see commits ordered
by timestamps, i.e. show C, E, B and D in this order before showing
A, possibly mixing commits from two parallel histories together.
When "lifo" parameter is set to false, the function keeps the "work
to be done" set sorted in the date order to realize this semantics.
After inspecting C, we add B to the "work to be done" set, but the
next commit we inspect from the set is E which is newer than B.
The name "lifo", however, is too strongly tied to the way how the
function implements its behaviour, and does not describe what the
behaviour _means_.
Replace this field with an enum rev_sort_order, with two possible
values: REV_SORT_IN_GRAPH_ORDER and REV_SORT_BY_COMMIT_DATE, and
update the existing code. The mechanical replacement rule is:
"lifo == 0" is equivalent to "sort_order == REV_SORT_BY_COMMIT_DATE"
"lifo == 1" is equivalent to "sort_order == REV_SORT_IN_GRAPH_ORDER"
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-06-06 23:07:14 +00:00
|
|
|
sort_in_topological_order(&list, revs->sort_order);
|
2007-11-03 18:11:10 +00:00
|
|
|
while (list && i) {
|
|
|
|
struct commit *commit = list->item;
|
2007-11-04 20:12:05 +00:00
|
|
|
switch (simplify_commit(revs, commit)) {
|
|
|
|
case commit_show:
|
|
|
|
if (show_header) {
|
|
|
|
int n = estimate_commit_count(revs, list);
|
|
|
|
show_early_header(revs, "incomplete", n);
|
|
|
|
show_header = 0;
|
|
|
|
}
|
|
|
|
log_tree_commit(revs, commit);
|
|
|
|
i--;
|
|
|
|
break;
|
|
|
|
case commit_ignore:
|
|
|
|
break;
|
|
|
|
case commit_error:
|
2016-06-22 15:01:28 +00:00
|
|
|
if (close_file)
|
|
|
|
fclose(revs->diffopt.file);
|
2007-11-04 20:12:05 +00:00
|
|
|
return;
|
|
|
|
}
|
2007-11-03 18:11:10 +00:00
|
|
|
list = list->next;
|
|
|
|
}
|
2007-11-04 20:12:05 +00:00
|
|
|
|
|
|
|
/* Did we already get enough commits for the early output? */
|
2016-06-22 15:01:28 +00:00
|
|
|
if (!i) {
|
|
|
|
if (close_file)
|
|
|
|
fclose(revs->diffopt.file);
|
2007-11-04 20:12:05 +00:00
|
|
|
return;
|
2016-06-22 15:01:28 +00:00
|
|
|
}
|
2007-11-04 20:12:05 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* ..if no, then repeat it twice a second until we
|
|
|
|
* do.
|
|
|
|
*
|
|
|
|
* NOTE! We don't use "it_interval", because if the
|
|
|
|
* reader isn't listening, we want our output to be
|
|
|
|
* throttled by the writing, and not have the timer
|
|
|
|
* trigger every second even if we're blocked on a
|
|
|
|
* reader!
|
|
|
|
*/
|
|
|
|
early_output_timer.it_value.tv_sec = 0;
|
|
|
|
early_output_timer.it_value.tv_usec = 500000;
|
|
|
|
setitimer(ITIMER_REAL, &early_output_timer, NULL);
|
2007-11-03 18:11:10 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void early_output(int signal)
|
|
|
|
{
|
|
|
|
show_early_output = log_show_early;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void setup_early_output(struct rev_info *rev)
|
|
|
|
{
|
|
|
|
struct sigaction sa;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Set up the signal handler, minimally intrusively:
|
|
|
|
* we only set a single volatile integer word (not
|
|
|
|
* using sigatomic_t - trying to avoid unnecessary
|
|
|
|
* system dependencies and headers), and using
|
|
|
|
* SA_RESTART.
|
|
|
|
*/
|
|
|
|
memset(&sa, 0, sizeof(sa));
|
|
|
|
sa.sa_handler = early_output;
|
|
|
|
sigemptyset(&sa.sa_mask);
|
|
|
|
sa.sa_flags = SA_RESTART;
|
|
|
|
sigaction(SIGALRM, &sa, NULL);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If we can get the whole output in less than a
|
|
|
|
* tenth of a second, don't even bother doing the
|
|
|
|
* early-output thing..
|
|
|
|
*
|
|
|
|
* This is a one-time-only trigger.
|
|
|
|
*/
|
2007-11-04 20:12:05 +00:00
|
|
|
early_output_timer.it_value.tv_sec = 0;
|
|
|
|
early_output_timer.it_value.tv_usec = 100000;
|
|
|
|
setitimer(ITIMER_REAL, &early_output_timer, NULL);
|
2007-11-03 18:11:10 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void finish_early_output(struct rev_info *rev)
|
|
|
|
{
|
2007-11-04 20:12:05 +00:00
|
|
|
int n = estimate_commit_count(rev, rev->commits);
|
2007-11-03 18:11:10 +00:00
|
|
|
signal(SIGALRM, SIG_IGN);
|
2007-11-04 20:12:05 +00:00
|
|
|
show_early_header(rev, "done", n);
|
2007-11-03 18:11:10 +00:00
|
|
|
}
|
|
|
|
|
2006-06-25 12:39:35 +00:00
|
|
|
static int cmd_log_walk(struct rev_info *rev)
|
|
|
|
{
|
|
|
|
struct commit *commit;
|
2011-01-06 21:50:06 +00:00
|
|
|
int saved_nrl = 0;
|
2016-06-22 15:01:28 +00:00
|
|
|
int saved_dcctc = 0, close_file = rev->diffopt.close_file;
|
2006-04-21 17:27:34 +00:00
|
|
|
|
2007-11-03 18:11:10 +00:00
|
|
|
if (rev->early_output)
|
|
|
|
setup_early_output(rev);
|
|
|
|
|
2008-02-18 07:31:56 +00:00
|
|
|
if (prepare_revision_walk(rev))
|
2011-02-22 23:41:57 +00:00
|
|
|
die(_("revision walk setup failed"));
|
2007-11-03 18:11:10 +00:00
|
|
|
|
|
|
|
if (rev->early_output)
|
|
|
|
finish_early_output(rev);
|
|
|
|
|
2008-08-11 06:46:24 +00:00
|
|
|
/*
|
2008-08-11 06:46:25 +00:00
|
|
|
* For --check and --exit-code, the exit code is based on CHECK_FAILED
|
|
|
|
* and HAS_CHANGES being accumulated in rev->diffopt, so be careful to
|
|
|
|
* retain that state information if replacing rev->diffopt in this loop
|
2008-08-11 06:46:24 +00:00
|
|
|
*/
|
2016-06-22 15:01:28 +00:00
|
|
|
rev->diffopt.close_file = 0;
|
2006-04-21 17:27:34 +00:00
|
|
|
while ((commit = get_revision(rev)) != NULL) {
|
2015-08-20 22:51:45 +00:00
|
|
|
if (!log_tree_commit(rev, commit) && rev->max_count >= 0)
|
2011-03-09 20:52:15 +00:00
|
|
|
/*
|
|
|
|
* We decremented max_count in get_revision,
|
|
|
|
* but we didn't actually show the commit.
|
|
|
|
*/
|
|
|
|
rev->max_count++;
|
2007-01-20 21:28:16 +00:00
|
|
|
if (!rev->reflog_info) {
|
|
|
|
/* we allow cycles in reflog ancestry */
|
provide a helper to free commit buffer
This converts two lines into one at each caller. But more
importantly, it abstracts the concept of freeing the buffer,
which will make it easier to change later.
Note that we also need to provide a "detach" mechanism for a
tricky case in index-pack. We are passed a buffer for the
object generated by processing the incoming pack. If we are
not using --strict, we just calculate the sha1 on that
buffer and return, leaving the caller to free it. But if we
are using --strict, we actually attach that buffer to an
object, pass the object to the fsck functions, and then
detach the buffer from the object again (so that the caller
can free it as usual). In this case, we don't want to free
the buffer ourselves, but just make sure it is no longer
associated with the commit.
Note that we are making the assumption here that the
attach/detach process does not impact the buffer at all
(e.g., it is never reallocated or modified). That holds true
now, and we have no plans to change that. However, as we
abstract the commit_buffer code, this dependency becomes
less obvious. So when we detach, let's also make sure that
we get back the same buffer that we gave to the
commit_buffer code.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2014-06-12 22:05:37 +00:00
|
|
|
free_commit_buffer(commit);
|
2007-01-20 21:28:16 +00:00
|
|
|
}
|
2006-06-18 01:47:58 +00:00
|
|
|
free_commit_list(commit->parents);
|
|
|
|
commit->parents = NULL;
|
2011-01-06 21:50:06 +00:00
|
|
|
if (saved_nrl < rev->diffopt.needed_rename_limit)
|
|
|
|
saved_nrl = rev->diffopt.needed_rename_limit;
|
|
|
|
if (rev->diffopt.degraded_cc_to_c)
|
|
|
|
saved_dcctc = 1;
|
2006-04-21 17:27:34 +00:00
|
|
|
}
|
2011-01-06 21:50:06 +00:00
|
|
|
rev->diffopt.degraded_cc_to_c = saved_dcctc;
|
|
|
|
rev->diffopt.needed_rename_limit = saved_nrl;
|
2016-06-22 15:01:28 +00:00
|
|
|
if (close_file)
|
|
|
|
fclose(rev->diffopt.file);
|
2011-01-06 21:50:06 +00:00
|
|
|
|
2008-08-11 06:46:24 +00:00
|
|
|
if (rev->diffopt.output_format & DIFF_FORMAT_CHECKDIFF &&
|
|
|
|
DIFF_OPT_TST(&rev->diffopt, CHECK_FAILED)) {
|
|
|
|
return 02;
|
|
|
|
}
|
2008-08-11 06:46:25 +00:00
|
|
|
return diff_result_code(&rev->diffopt, 0);
|
2006-04-21 17:27:34 +00:00
|
|
|
}
|
|
|
|
|
2008-05-14 17:46:53 +00:00
|
|
|
static int git_log_config(const char *var, const char *value, void *cb)
|
2006-11-23 09:36:33 +00:00
|
|
|
{
|
2014-10-04 18:54:50 +00:00
|
|
|
const char *slot_name;
|
|
|
|
|
2008-03-02 09:05:53 +00:00
|
|
|
if (!strcmp(var, "format.pretty"))
|
|
|
|
return git_config_string(&fmt_pretty, var, value);
|
2008-07-05 05:24:41 +00:00
|
|
|
if (!strcmp(var, "format.subjectprefix"))
|
|
|
|
return git_config_string(&fmt_patch_subject_prefix, var, value);
|
2011-05-18 17:56:04 +00:00
|
|
|
if (!strcmp(var, "log.abbrevcommit")) {
|
|
|
|
default_abbrev_commit = git_config_bool(var, value);
|
|
|
|
return 0;
|
|
|
|
}
|
2008-05-22 15:24:07 +00:00
|
|
|
if (!strcmp(var, "log.date"))
|
|
|
|
return git_config_string(&default_date_mode, var, value);
|
2010-02-16 23:39:52 +00:00
|
|
|
if (!strcmp(var, "log.decorate")) {
|
2010-02-17 18:20:49 +00:00
|
|
|
decoration_style = parse_decoration_style(var, value);
|
|
|
|
if (decoration_style < 0)
|
|
|
|
decoration_style = 0; /* maybe warn? */
|
2010-02-16 23:39:52 +00:00
|
|
|
return 0;
|
|
|
|
}
|
2006-11-23 09:36:33 +00:00
|
|
|
if (!strcmp(var, "log.showroot")) {
|
|
|
|
default_show_root = git_config_bool(var, value);
|
|
|
|
return 0;
|
|
|
|
}
|
2015-07-08 01:29:34 +00:00
|
|
|
if (!strcmp(var, "log.follow")) {
|
|
|
|
default_follow = git_config_bool(var, value);
|
|
|
|
return 0;
|
|
|
|
}
|
2014-10-04 18:54:50 +00:00
|
|
|
if (skip_prefix(var, "color.decorate.", &slot_name))
|
2014-10-20 19:23:48 +00:00
|
|
|
return parse_decorate_color_config(var, slot_name, value);
|
2013-01-05 21:26:46 +00:00
|
|
|
if (!strcmp(var, "log.mailmap")) {
|
|
|
|
use_mailmap_config = git_config_bool(var, value);
|
|
|
|
return 0;
|
|
|
|
}
|
2016-06-22 16:51:26 +00:00
|
|
|
if (!strcmp(var, "log.showsignature")) {
|
|
|
|
default_show_signature = git_config_bool(var, value);
|
|
|
|
return 0;
|
|
|
|
}
|
2013-01-05 21:26:46 +00:00
|
|
|
|
2012-10-09 23:49:57 +00:00
|
|
|
if (grep_config(var, value, cb) < 0)
|
|
|
|
return -1;
|
2013-03-27 15:13:39 +00:00
|
|
|
if (git_gpg_config(var, value, cb) < 0)
|
2012-10-09 23:49:57 +00:00
|
|
|
return -1;
|
2008-05-14 17:46:53 +00:00
|
|
|
return git_diff_ui_config(var, value, cb);
|
2006-11-23 09:36:33 +00:00
|
|
|
}
|
|
|
|
|
2006-07-29 05:44:25 +00:00
|
|
|
int cmd_whatchanged(int argc, const char **argv, const char *prefix)
|
2006-04-21 17:27:34 +00:00
|
|
|
{
|
|
|
|
struct rev_info rev;
|
2010-03-09 06:58:09 +00:00
|
|
|
struct setup_revision_opt opt;
|
2006-04-21 17:27:34 +00:00
|
|
|
|
2016-02-25 08:59:20 +00:00
|
|
|
init_log_defaults();
|
2008-05-14 17:46:53 +00:00
|
|
|
git_config(git_log_config, NULL);
|
2008-02-18 07:26:03 +00:00
|
|
|
|
2006-07-29 04:21:48 +00:00
|
|
|
init_revisions(&rev, prefix);
|
2006-04-21 17:27:34 +00:00
|
|
|
rev.diff = 1;
|
2006-06-11 17:57:35 +00:00
|
|
|
rev.simplify_history = 0;
|
2010-03-09 06:58:09 +00:00
|
|
|
memset(&opt, 0, sizeof(opt));
|
|
|
|
opt.def = "HEAD";
|
2012-07-02 19:43:05 +00:00
|
|
|
opt.revarg_opt = REVARG_COMMITTISH;
|
2010-03-09 06:58:09 +00:00
|
|
|
cmd_log_init(argc, argv, prefix, &rev, &opt);
|
2006-06-25 12:39:35 +00:00
|
|
|
if (!rev.diffopt.output_format)
|
|
|
|
rev.diffopt.output_format = DIFF_FORMAT_RAW;
|
|
|
|
return cmd_log_walk(&rev);
|
2006-04-21 17:27:34 +00:00
|
|
|
}
|
|
|
|
|
2007-12-18 18:01:33 +00:00
|
|
|
static void show_tagger(char *buf, int len, struct rev_info *rev)
|
|
|
|
{
|
2009-01-02 18:08:43 +00:00
|
|
|
struct strbuf out = STRBUF_INIT;
|
2011-05-26 22:27:49 +00:00
|
|
|
struct pretty_print_context pp = {0};
|
2007-12-18 18:01:33 +00:00
|
|
|
|
2011-05-26 22:27:49 +00:00
|
|
|
pp.fmt = rev->commit_format;
|
|
|
|
pp.date_mode = rev->date_mode;
|
|
|
|
pp_user_info(&pp, "Tagger", &out, buf, get_log_output_encoding());
|
2016-06-22 15:01:59 +00:00
|
|
|
fprintf(rev->diffopt.file, "%s", out.buf);
|
2009-01-02 18:08:43 +00:00
|
|
|
strbuf_release(&out);
|
2007-12-18 18:01:33 +00:00
|
|
|
}
|
|
|
|
|
2013-05-10 15:10:12 +00:00
|
|
|
static int show_blob_object(const unsigned char *sha1, struct rev_info *rev, const char *obj_name)
|
2012-03-07 10:54:19 +00:00
|
|
|
{
|
2013-05-10 15:10:12 +00:00
|
|
|
unsigned char sha1c[20];
|
|
|
|
struct object_context obj_context;
|
|
|
|
char *buf;
|
|
|
|
unsigned long size;
|
|
|
|
|
2016-06-22 15:01:59 +00:00
|
|
|
fflush(rev->diffopt.file);
|
2013-05-10 15:10:12 +00:00
|
|
|
if (!DIFF_OPT_TOUCHED(&rev->diffopt, ALLOW_TEXTCONV) ||
|
|
|
|
!DIFF_OPT_TST(&rev->diffopt, ALLOW_TEXTCONV))
|
|
|
|
return stream_blob_to_fd(1, sha1, NULL, 0);
|
|
|
|
|
|
|
|
if (get_sha1_with_context(obj_name, 0, sha1c, &obj_context))
|
2014-09-14 22:07:10 +00:00
|
|
|
die(_("Not a valid object name %s"), obj_name);
|
2013-05-10 15:10:12 +00:00
|
|
|
if (!obj_context.path[0] ||
|
|
|
|
!textconv_object(obj_context.path, obj_context.mode, sha1c, 1, &buf, &size))
|
|
|
|
return stream_blob_to_fd(1, sha1, NULL, 0);
|
|
|
|
|
|
|
|
if (!buf)
|
2014-09-14 22:07:10 +00:00
|
|
|
die(_("git show %s: bad file"), obj_name);
|
2013-05-10 15:10:12 +00:00
|
|
|
|
|
|
|
write_or_die(1, buf, size);
|
|
|
|
return 0;
|
2012-03-07 10:54:19 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int show_tag_object(const unsigned char *sha1, struct rev_info *rev)
|
2006-12-14 10:31:05 +00:00
|
|
|
{
|
|
|
|
unsigned long size;
|
2007-02-26 19:55:59 +00:00
|
|
|
enum object_type type;
|
|
|
|
char *buf = read_sha1_file(sha1, &type, &size);
|
2006-12-14 10:31:05 +00:00
|
|
|
int offset = 0;
|
|
|
|
|
|
|
|
if (!buf)
|
2011-02-22 23:41:57 +00:00
|
|
|
return error(_("Could not read object %s"), sha1_to_hex(sha1));
|
2006-12-14 10:31:05 +00:00
|
|
|
|
2012-03-07 10:54:19 +00:00
|
|
|
assert(type == OBJ_TAG);
|
|
|
|
while (offset < size && buf[offset] != '\n') {
|
|
|
|
int new_offset = offset + 1;
|
|
|
|
while (new_offset < size && buf[new_offset++] != '\n')
|
|
|
|
; /* do nothing */
|
2013-11-30 20:55:40 +00:00
|
|
|
if (starts_with(buf + offset, "tagger "))
|
2012-03-07 10:54:19 +00:00
|
|
|
show_tagger(buf + offset + 7,
|
|
|
|
new_offset - offset - 7, rev);
|
|
|
|
offset = new_offset;
|
|
|
|
}
|
2006-12-14 10:31:05 +00:00
|
|
|
|
|
|
|
if (offset < size)
|
2016-06-22 15:01:59 +00:00
|
|
|
fwrite(buf + offset, size - offset, 1, rev->diffopt.file);
|
2006-12-14 10:31:05 +00:00
|
|
|
free(buf);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int show_tree_object(const unsigned char *sha1,
|
2014-11-30 09:05:00 +00:00
|
|
|
struct strbuf *base,
|
2008-07-14 19:22:12 +00:00
|
|
|
const char *pathname, unsigned mode, int stage, void *context)
|
2006-12-14 10:31:05 +00:00
|
|
|
{
|
2016-06-22 15:01:59 +00:00
|
|
|
FILE *file = context;
|
|
|
|
fprintf(file, "%s%s\n", pathname, S_ISDIR(mode) ? "/" : "");
|
2006-12-14 10:31:05 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2015-08-20 21:14:46 +00:00
|
|
|
static void show_setup_revisions_tweak(struct rev_info *rev,
|
|
|
|
struct setup_revision_opt *opt)
|
2010-03-09 07:27:25 +00:00
|
|
|
{
|
2010-03-09 08:22:54 +00:00
|
|
|
if (rev->ignore_merges) {
|
|
|
|
/* There was no "-m" on the command line */
|
|
|
|
rev->ignore_merges = 0;
|
|
|
|
if (!rev->first_parent_only && !rev->combine_merges) {
|
2014-03-31 22:11:46 +00:00
|
|
|
/* No "--first-parent", "-c", or "--cc" */
|
2010-03-09 08:22:54 +00:00
|
|
|
rev->combine_merges = 1;
|
|
|
|
rev->dense_combined_merges = 1;
|
|
|
|
}
|
|
|
|
}
|
2010-03-09 07:27:25 +00:00
|
|
|
if (!rev->diffopt.output_format)
|
|
|
|
rev->diffopt.output_format = DIFF_FORMAT_PATCH;
|
|
|
|
}
|
|
|
|
|
2006-07-29 05:44:25 +00:00
|
|
|
int cmd_show(int argc, const char **argv, const char *prefix)
|
2006-04-21 17:27:34 +00:00
|
|
|
{
|
|
|
|
struct rev_info rev;
|
2006-12-14 10:31:05 +00:00
|
|
|
struct object_array_entry *objects;
|
2010-03-09 06:58:09 +00:00
|
|
|
struct setup_revision_opt opt;
|
2011-03-25 09:34:19 +00:00
|
|
|
struct pathspec match_all;
|
2006-12-14 10:31:05 +00:00
|
|
|
int i, count, ret = 0;
|
2006-04-21 17:27:34 +00:00
|
|
|
|
2016-02-25 08:59:20 +00:00
|
|
|
init_log_defaults();
|
2008-05-14 17:46:53 +00:00
|
|
|
git_config(git_log_config, NULL);
|
2008-02-18 07:26:03 +00:00
|
|
|
|
2013-07-14 08:35:59 +00:00
|
|
|
memset(&match_all, 0, sizeof(match_all));
|
2006-07-29 04:21:48 +00:00
|
|
|
init_revisions(&rev, prefix);
|
2006-04-21 17:27:34 +00:00
|
|
|
rev.diff = 1;
|
|
|
|
rev.always_show_header = 1;
|
teach log --no-walk=unsorted, which avoids sorting
When 'git log' is passed the --no-walk option, no revision walk takes
place, naturally. Perhaps somewhat surprisingly, however, the provided
revisions still get sorted by commit date. So e.g 'git log --no-walk
HEAD HEAD~1' and 'git log --no-walk HEAD~1 HEAD' give the same result
(unless the two revisions share the commit date, in which case they
will retain the order given on the command line). As the commit that
introduced --no-walk (8e64006 (Teach revision machinery about
--no-walk, 2007-07-24)) points out, the sorting is intentional, to
allow things like
git log --abbrev-commit --pretty=oneline --decorate --all --no-walk
to show all refs in order by commit date.
But there are also other cases where the sorting is not wanted, such
as
<command producing revisions in order> |
git log --oneline --no-walk --stdin
To accomodate both cases, leave the decision of whether or not to sort
up to the caller, by allowing --no-walk={sorted,unsorted}, defaulting
to 'sorted' for backward-compatibility reasons.
Signed-off-by: Martin von Zweigbergk <martinvonz@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2012-08-29 06:15:54 +00:00
|
|
|
rev.no_walk = REVISION_WALK_NO_WALK_SORTED;
|
2012-03-01 12:26:40 +00:00
|
|
|
rev.diffopt.stat_width = -1; /* Scale to real terminal size */
|
|
|
|
|
2010-03-09 06:58:09 +00:00
|
|
|
memset(&opt, 0, sizeof(opt));
|
|
|
|
opt.def = "HEAD";
|
2015-08-20 21:14:46 +00:00
|
|
|
opt.tweak = show_setup_revisions_tweak;
|
2010-03-09 06:58:09 +00:00
|
|
|
cmd_log_init(argc, argv, prefix, &rev, &opt);
|
2006-12-14 10:31:05 +00:00
|
|
|
|
2012-06-19 21:15:57 +00:00
|
|
|
if (!rev.no_walk)
|
|
|
|
return cmd_log_walk(&rev);
|
|
|
|
|
2006-12-14 10:31:05 +00:00
|
|
|
count = rev.pending.nr;
|
|
|
|
objects = rev.pending.objects;
|
|
|
|
for (i = 0; i < count && !ret; i++) {
|
|
|
|
struct object *o = objects[i].item;
|
|
|
|
const char *name = objects[i].name;
|
|
|
|
switch (o->type) {
|
|
|
|
case OBJ_BLOB:
|
2015-11-10 02:22:29 +00:00
|
|
|
ret = show_blob_object(o->oid.hash, &rev, name);
|
2006-12-14 10:31:05 +00:00
|
|
|
break;
|
|
|
|
case OBJ_TAG: {
|
|
|
|
struct tag *t = (struct tag *)o;
|
|
|
|
|
show: add space between multiple items
When showing an annotated tag, "git show" will always
display the pointed-to object. However, it didn't separate
the two with whitespace, making it more difficult to notice
where the new object started. For example:
$ git tag -m 'my message' foo
$ git show foo
tag foo
Tagger: Jeff King <peff@peff.net>
Date: Fri Jul 17 18:46:25 2009 -0400
my message
commit 41cabf8fed2694ba33e01d64f9094f2fc5e5805a
Author: Jeff King <peff@peff.net>
Date: Thu Jul 16 17:31:34 2009 -0400
...
This patch respects and sets the rev.shown_one member to
prepend a blank line before showing a second item. We use
this member of rev_info instead of a local flag, because the
log_tree_commit we call into for showing commits already
respects and sets that flag. Meaning that everything will be
spaced properly if you intermix commits and tags, like:
$ git show v1.6.3 v1.6.2 HEAD
In that case, a single blank line will separate the first
tag, the commit it points to, the second tag, the commit
that one points to, and the final commit.
While we're at it, let's also support trees, so that even
something as crazy as
$ git show HEAD^{tree} HEAD~1^{tree} HEAD
will also be spaced in an easy-to-read way. However, we
intentionally do _not_ insert blank lines for blobs, so
that specifying multiple blobs gives a strict concatenation.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2009-07-18 10:14:37 +00:00
|
|
|
if (rev.shown_one)
|
|
|
|
putchar('\n');
|
2016-06-22 15:01:59 +00:00
|
|
|
fprintf(rev.diffopt.file, "%stag %s%s\n",
|
2007-11-10 19:05:14 +00:00
|
|
|
diff_get_color_opt(&rev.diffopt, DIFF_COMMIT),
|
2006-12-14 10:31:05 +00:00
|
|
|
t->tag,
|
2007-11-10 19:05:14 +00:00
|
|
|
diff_get_color_opt(&rev.diffopt, DIFF_RESET));
|
2015-11-10 02:22:29 +00:00
|
|
|
ret = show_tag_object(o->oid.hash, &rev);
|
show: add space between multiple items
When showing an annotated tag, "git show" will always
display the pointed-to object. However, it didn't separate
the two with whitespace, making it more difficult to notice
where the new object started. For example:
$ git tag -m 'my message' foo
$ git show foo
tag foo
Tagger: Jeff King <peff@peff.net>
Date: Fri Jul 17 18:46:25 2009 -0400
my message
commit 41cabf8fed2694ba33e01d64f9094f2fc5e5805a
Author: Jeff King <peff@peff.net>
Date: Thu Jul 16 17:31:34 2009 -0400
...
This patch respects and sets the rev.shown_one member to
prepend a blank line before showing a second item. We use
this member of rev_info instead of a local flag, because the
log_tree_commit we call into for showing commits already
respects and sets that flag. Meaning that everything will be
spaced properly if you intermix commits and tags, like:
$ git show v1.6.3 v1.6.2 HEAD
In that case, a single blank line will separate the first
tag, the commit it points to, the second tag, the commit
that one points to, and the final commit.
While we're at it, let's also support trees, so that even
something as crazy as
$ git show HEAD^{tree} HEAD~1^{tree} HEAD
will also be spaced in an easy-to-read way. However, we
intentionally do _not_ insert blank lines for blobs, so
that specifying multiple blobs gives a strict concatenation.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2009-07-18 10:14:37 +00:00
|
|
|
rev.shown_one = 1;
|
2008-12-15 08:36:56 +00:00
|
|
|
if (ret)
|
|
|
|
break;
|
2015-11-10 02:22:29 +00:00
|
|
|
o = parse_object(t->tagged->oid.hash);
|
2008-12-15 08:36:56 +00:00
|
|
|
if (!o)
|
2011-02-22 23:41:57 +00:00
|
|
|
ret = error(_("Could not read object %s"),
|
2015-11-10 02:22:28 +00:00
|
|
|
oid_to_hex(&t->tagged->oid));
|
2008-12-15 08:36:56 +00:00
|
|
|
objects[i].item = o;
|
2006-12-14 10:31:05 +00:00
|
|
|
i--;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case OBJ_TREE:
|
show: add space between multiple items
When showing an annotated tag, "git show" will always
display the pointed-to object. However, it didn't separate
the two with whitespace, making it more difficult to notice
where the new object started. For example:
$ git tag -m 'my message' foo
$ git show foo
tag foo
Tagger: Jeff King <peff@peff.net>
Date: Fri Jul 17 18:46:25 2009 -0400
my message
commit 41cabf8fed2694ba33e01d64f9094f2fc5e5805a
Author: Jeff King <peff@peff.net>
Date: Thu Jul 16 17:31:34 2009 -0400
...
This patch respects and sets the rev.shown_one member to
prepend a blank line before showing a second item. We use
this member of rev_info instead of a local flag, because the
log_tree_commit we call into for showing commits already
respects and sets that flag. Meaning that everything will be
spaced properly if you intermix commits and tags, like:
$ git show v1.6.3 v1.6.2 HEAD
In that case, a single blank line will separate the first
tag, the commit it points to, the second tag, the commit
that one points to, and the final commit.
While we're at it, let's also support trees, so that even
something as crazy as
$ git show HEAD^{tree} HEAD~1^{tree} HEAD
will also be spaced in an easy-to-read way. However, we
intentionally do _not_ insert blank lines for blobs, so
that specifying multiple blobs gives a strict concatenation.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2009-07-18 10:14:37 +00:00
|
|
|
if (rev.shown_one)
|
|
|
|
putchar('\n');
|
2016-06-22 15:01:59 +00:00
|
|
|
fprintf(rev.diffopt.file, "%stree %s%s\n\n",
|
2007-11-10 19:05:14 +00:00
|
|
|
diff_get_color_opt(&rev.diffopt, DIFF_COMMIT),
|
2006-12-14 10:31:05 +00:00
|
|
|
name,
|
2007-11-10 19:05:14 +00:00
|
|
|
diff_get_color_opt(&rev.diffopt, DIFF_RESET));
|
2011-03-25 09:34:19 +00:00
|
|
|
read_tree_recursive((struct tree *)o, "", 0, 0, &match_all,
|
2016-06-22 15:01:59 +00:00
|
|
|
show_tree_object, rev.diffopt.file);
|
show: add space between multiple items
When showing an annotated tag, "git show" will always
display the pointed-to object. However, it didn't separate
the two with whitespace, making it more difficult to notice
where the new object started. For example:
$ git tag -m 'my message' foo
$ git show foo
tag foo
Tagger: Jeff King <peff@peff.net>
Date: Fri Jul 17 18:46:25 2009 -0400
my message
commit 41cabf8fed2694ba33e01d64f9094f2fc5e5805a
Author: Jeff King <peff@peff.net>
Date: Thu Jul 16 17:31:34 2009 -0400
...
This patch respects and sets the rev.shown_one member to
prepend a blank line before showing a second item. We use
this member of rev_info instead of a local flag, because the
log_tree_commit we call into for showing commits already
respects and sets that flag. Meaning that everything will be
spaced properly if you intermix commits and tags, like:
$ git show v1.6.3 v1.6.2 HEAD
In that case, a single blank line will separate the first
tag, the commit it points to, the second tag, the commit
that one points to, and the final commit.
While we're at it, let's also support trees, so that even
something as crazy as
$ git show HEAD^{tree} HEAD~1^{tree} HEAD
will also be spaced in an easy-to-read way. However, we
intentionally do _not_ insert blank lines for blobs, so
that specifying multiple blobs gives a strict concatenation.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2009-07-18 10:14:37 +00:00
|
|
|
rev.shown_one = 1;
|
2006-12-14 10:31:05 +00:00
|
|
|
break;
|
|
|
|
case OBJ_COMMIT:
|
|
|
|
rev.pending.nr = rev.pending.alloc = 0;
|
|
|
|
rev.pending.objects = NULL;
|
|
|
|
add_object_array(o, name, &rev.pending);
|
|
|
|
ret = cmd_log_walk(&rev);
|
|
|
|
break;
|
|
|
|
default:
|
2011-02-22 23:41:57 +00:00
|
|
|
ret = error(_("Unknown type: %d"), o->type);
|
2006-12-14 10:31:05 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
free(objects);
|
|
|
|
return ret;
|
2006-04-21 17:27:34 +00:00
|
|
|
}
|
|
|
|
|
2007-02-08 17:51:56 +00:00
|
|
|
/*
|
|
|
|
* This is equivalent to "git log -g --abbrev-commit --pretty=oneline"
|
|
|
|
*/
|
|
|
|
int cmd_log_reflog(int argc, const char **argv, const char *prefix)
|
|
|
|
{
|
|
|
|
struct rev_info rev;
|
2010-03-09 06:58:09 +00:00
|
|
|
struct setup_revision_opt opt;
|
2007-02-08 17:51:56 +00:00
|
|
|
|
2016-02-25 08:59:20 +00:00
|
|
|
init_log_defaults();
|
2008-05-14 17:46:53 +00:00
|
|
|
git_config(git_log_config, NULL);
|
2008-02-18 07:26:03 +00:00
|
|
|
|
2007-02-08 17:51:56 +00:00
|
|
|
init_revisions(&rev, prefix);
|
|
|
|
init_reflog_walk(&rev.reflog_info);
|
|
|
|
rev.verbose_header = 1;
|
2010-03-09 06:58:09 +00:00
|
|
|
memset(&opt, 0, sizeof(opt));
|
|
|
|
opt.def = "HEAD";
|
2011-04-01 09:20:33 +00:00
|
|
|
cmd_log_init_defaults(&rev);
|
2011-05-18 17:56:04 +00:00
|
|
|
rev.abbrev_commit = 1;
|
2007-02-08 17:51:56 +00:00
|
|
|
rev.commit_format = CMIT_FMT_ONELINE;
|
2008-04-08 00:11:34 +00:00
|
|
|
rev.use_terminator = 1;
|
2007-02-08 17:51:56 +00:00
|
|
|
rev.always_show_header = 1;
|
2011-04-01 09:20:33 +00:00
|
|
|
cmd_log_init_finish(argc, argv, prefix, &rev, &opt);
|
2007-02-08 17:51:56 +00:00
|
|
|
|
|
|
|
return cmd_log_walk(&rev);
|
|
|
|
}
|
|
|
|
|
2015-08-20 21:14:46 +00:00
|
|
|
static void log_setup_revisions_tweak(struct rev_info *rev,
|
|
|
|
struct setup_revision_opt *opt)
|
2015-07-08 01:29:34 +00:00
|
|
|
{
|
|
|
|
if (DIFF_OPT_TST(&rev->diffopt, DEFAULT_FOLLOW_RENAMES) &&
|
|
|
|
rev->prune_data.nr == 1)
|
|
|
|
DIFF_OPT_SET(&rev->diffopt, FOLLOW_RENAMES);
|
2015-08-20 21:36:49 +00:00
|
|
|
|
|
|
|
/* Turn --cc/-c into -p --cc/-c when -p was not given */
|
|
|
|
if (!rev->diffopt.output_format && rev->combine_merges)
|
|
|
|
rev->diffopt.output_format = DIFF_FORMAT_PATCH;
|
2015-08-20 21:36:49 +00:00
|
|
|
|
|
|
|
/* Turn -m on when --cc/-c was given */
|
|
|
|
if (rev->combine_merges)
|
|
|
|
rev->ignore_merges = 0;
|
2015-07-08 01:29:34 +00:00
|
|
|
}
|
|
|
|
|
2006-07-29 05:44:25 +00:00
|
|
|
int cmd_log(int argc, const char **argv, const char *prefix)
|
2006-04-21 17:27:34 +00:00
|
|
|
{
|
|
|
|
struct rev_info rev;
|
2010-03-09 06:58:09 +00:00
|
|
|
struct setup_revision_opt opt;
|
2006-04-21 17:27:34 +00:00
|
|
|
|
2016-02-25 08:59:20 +00:00
|
|
|
init_log_defaults();
|
2008-05-14 17:46:53 +00:00
|
|
|
git_config(git_log_config, NULL);
|
2008-02-18 07:26:03 +00:00
|
|
|
|
2006-07-29 04:21:48 +00:00
|
|
|
init_revisions(&rev, prefix);
|
2006-04-21 17:27:34 +00:00
|
|
|
rev.always_show_header = 1;
|
2010-03-09 06:58:09 +00:00
|
|
|
memset(&opt, 0, sizeof(opt));
|
|
|
|
opt.def = "HEAD";
|
2012-07-02 19:43:05 +00:00
|
|
|
opt.revarg_opt = REVARG_COMMITTISH;
|
2015-08-20 21:14:46 +00:00
|
|
|
opt.tweak = log_setup_revisions_tweak;
|
2010-03-09 06:58:09 +00:00
|
|
|
cmd_log_init(argc, argv, prefix, &rev, &opt);
|
2006-06-25 12:39:35 +00:00
|
|
|
return cmd_log_walk(&rev);
|
2006-04-21 17:27:34 +00:00
|
|
|
}
|
2006-04-21 20:19:58 +00:00
|
|
|
|
2007-02-23 22:27:58 +00:00
|
|
|
/* format-patch */
|
2006-05-04 23:16:40 +00:00
|
|
|
|
2007-01-17 23:03:39 +00:00
|
|
|
static const char *fmt_patch_suffix = ".patch";
|
2007-11-04 03:38:24 +00:00
|
|
|
static int numbered = 0;
|
2008-10-02 20:55:39 +00:00
|
|
|
static int auto_number = 1;
|
2006-06-02 13:21:17 +00:00
|
|
|
|
2009-02-12 15:51:55 +00:00
|
|
|
static char *default_attach = NULL;
|
|
|
|
|
2016-06-13 10:04:20 +00:00
|
|
|
static struct string_list extra_hdr = STRING_LIST_INIT_NODUP;
|
|
|
|
static struct string_list extra_to = STRING_LIST_INIT_NODUP;
|
|
|
|
static struct string_list extra_cc = STRING_LIST_INIT_NODUP;
|
2008-02-19 07:40:33 +00:00
|
|
|
|
|
|
|
static void add_header(const char *value)
|
|
|
|
{
|
2010-03-07 22:46:46 +00:00
|
|
|
struct string_list_item *item;
|
2008-02-19 07:40:33 +00:00
|
|
|
int len = strlen(value);
|
2008-08-19 18:42:04 +00:00
|
|
|
while (len && value[len - 1] == '\n')
|
2008-02-19 07:40:33 +00:00
|
|
|
len--;
|
2010-03-07 22:46:46 +00:00
|
|
|
|
2008-02-19 07:40:33 +00:00
|
|
|
if (!strncasecmp(value, "to: ", 4)) {
|
2010-06-25 23:41:38 +00:00
|
|
|
item = string_list_append(&extra_to, value + 4);
|
2010-03-07 22:46:46 +00:00
|
|
|
len -= 4;
|
|
|
|
} else if (!strncasecmp(value, "cc: ", 4)) {
|
2010-06-25 23:41:38 +00:00
|
|
|
item = string_list_append(&extra_cc, value + 4);
|
2010-03-07 22:46:46 +00:00
|
|
|
len -= 4;
|
|
|
|
} else {
|
2010-06-25 23:41:38 +00:00
|
|
|
item = string_list_append(&extra_hdr, value);
|
2008-02-19 07:40:33 +00:00
|
|
|
}
|
2010-03-07 22:46:46 +00:00
|
|
|
|
|
|
|
item->string[len] = '\0';
|
2008-02-19 07:40:33 +00:00
|
|
|
}
|
|
|
|
|
2009-02-19 21:26:33 +00:00
|
|
|
#define THREAD_SHALLOW 1
|
|
|
|
#define THREAD_DEEP 2
|
2010-06-16 05:59:25 +00:00
|
|
|
static int thread;
|
|
|
|
static int do_signoff;
|
2016-04-26 07:51:24 +00:00
|
|
|
static int base_auto;
|
2016-07-30 09:41:56 +00:00
|
|
|
static char *from;
|
2010-06-16 05:59:25 +00:00
|
|
|
static const char *signature = git_version_string;
|
2014-05-24 04:08:14 +00:00
|
|
|
static const char *signature_file;
|
2013-04-07 17:46:23 +00:00
|
|
|
static int config_cover_letter;
|
2016-01-13 13:20:11 +00:00
|
|
|
static const char *config_output_directory;
|
2013-04-07 17:46:23 +00:00
|
|
|
|
|
|
|
enum {
|
|
|
|
COVER_UNSET,
|
|
|
|
COVER_OFF,
|
|
|
|
COVER_ON,
|
|
|
|
COVER_AUTO
|
|
|
|
};
|
2009-02-19 21:26:33 +00:00
|
|
|
|
2008-05-14 17:46:53 +00:00
|
|
|
static int git_format_config(const char *var, const char *value, void *cb)
|
2006-06-02 13:21:17 +00:00
|
|
|
{
|
|
|
|
if (!strcmp(var, "format.headers")) {
|
2007-01-17 19:13:02 +00:00
|
|
|
if (!value)
|
2011-02-22 23:41:57 +00:00
|
|
|
die(_("format.headers without value"));
|
2008-02-19 07:40:33 +00:00
|
|
|
add_header(value);
|
2006-06-02 13:21:17 +00:00
|
|
|
return 0;
|
|
|
|
}
|
2008-07-05 05:24:41 +00:00
|
|
|
if (!strcmp(var, "format.suffix"))
|
|
|
|
return git_config_string(&fmt_patch_suffix, var, value);
|
2010-02-16 23:39:34 +00:00
|
|
|
if (!strcmp(var, "format.to")) {
|
|
|
|
if (!value)
|
|
|
|
return config_error_nonbool(var);
|
2010-06-25 23:41:38 +00:00
|
|
|
string_list_append(&extra_to, value);
|
2010-02-16 23:39:34 +00:00
|
|
|
return 0;
|
|
|
|
}
|
2008-04-26 21:19:06 +00:00
|
|
|
if (!strcmp(var, "format.cc")) {
|
|
|
|
if (!value)
|
|
|
|
return config_error_nonbool(var);
|
2010-06-25 23:41:38 +00:00
|
|
|
string_list_append(&extra_cc, value);
|
2008-04-26 21:19:06 +00:00
|
|
|
return 0;
|
|
|
|
}
|
2011-09-12 17:46:41 +00:00
|
|
|
if (!strcmp(var, "diff.color") || !strcmp(var, "color.diff") ||
|
2015-01-07 20:32:12 +00:00
|
|
|
!strcmp(var, "color.ui") || !strcmp(var, "diff.submodule")) {
|
2006-07-09 06:28:21 +00:00
|
|
|
return 0;
|
|
|
|
}
|
2007-11-04 03:38:24 +00:00
|
|
|
if (!strcmp(var, "format.numbered")) {
|
2008-02-11 21:09:16 +00:00
|
|
|
if (value && !strcasecmp(value, "auto")) {
|
2007-11-04 03:38:24 +00:00
|
|
|
auto_number = 1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
numbered = git_config_bool(var, value);
|
2008-10-02 20:55:39 +00:00
|
|
|
auto_number = auto_number && numbered;
|
2007-11-04 03:38:24 +00:00
|
|
|
return 0;
|
|
|
|
}
|
2009-02-12 15:51:55 +00:00
|
|
|
if (!strcmp(var, "format.attach")) {
|
|
|
|
if (value && *value)
|
|
|
|
default_attach = xstrdup(value);
|
|
|
|
else
|
|
|
|
default_attach = xstrdup(git_version_string);
|
|
|
|
return 0;
|
|
|
|
}
|
2009-02-19 21:26:33 +00:00
|
|
|
if (!strcmp(var, "format.thread")) {
|
|
|
|
if (value && !strcasecmp(value, "deep")) {
|
|
|
|
thread = THREAD_DEEP;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
if (value && !strcasecmp(value, "shallow")) {
|
|
|
|
thread = THREAD_SHALLOW;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
thread = git_config_bool(var, value) && THREAD_SHALLOW;
|
|
|
|
return 0;
|
|
|
|
}
|
2009-04-01 17:51:54 +00:00
|
|
|
if (!strcmp(var, "format.signoff")) {
|
|
|
|
do_signoff = git_config_bool(var, value);
|
|
|
|
return 0;
|
|
|
|
}
|
2010-06-16 05:59:25 +00:00
|
|
|
if (!strcmp(var, "format.signature"))
|
|
|
|
return git_config_string(&signature, var, value);
|
2014-05-24 04:08:14 +00:00
|
|
|
if (!strcmp(var, "format.signaturefile"))
|
|
|
|
return git_config_pathname(&signature_file, var, value);
|
2013-04-07 17:46:23 +00:00
|
|
|
if (!strcmp(var, "format.coverletter")) {
|
|
|
|
if (value && !strcasecmp(value, "auto")) {
|
|
|
|
config_cover_letter = COVER_AUTO;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
config_cover_letter = git_config_bool(var, value) ? COVER_ON : COVER_OFF;
|
|
|
|
return 0;
|
|
|
|
}
|
2016-01-13 13:20:11 +00:00
|
|
|
if (!strcmp(var, "format.outputdirectory"))
|
|
|
|
return git_config_string(&config_output_directory, var, value);
|
2016-04-26 07:51:24 +00:00
|
|
|
if (!strcmp(var, "format.useautobase")) {
|
|
|
|
base_auto = git_config_bool(var, value);
|
|
|
|
return 0;
|
|
|
|
}
|
2016-07-30 09:41:56 +00:00
|
|
|
if (!strcmp(var, "format.from")) {
|
|
|
|
int b = git_config_maybe_bool(var, value);
|
|
|
|
free(from);
|
|
|
|
if (b < 0)
|
|
|
|
from = xstrdup(value);
|
|
|
|
else if (b)
|
|
|
|
from = xstrdup(git_committer_info(IDENT_NO_DATE));
|
|
|
|
else
|
|
|
|
from = NULL;
|
|
|
|
return 0;
|
|
|
|
}
|
2007-07-02 00:48:59 +00:00
|
|
|
|
2008-05-14 17:46:53 +00:00
|
|
|
return git_log_config(var, value, cb);
|
2006-06-02 13:21:17 +00:00
|
|
|
}
|
|
|
|
|
2006-06-06 15:46:23 +00:00
|
|
|
static const char *output_directory = NULL;
|
2009-01-12 23:18:02 +00:00
|
|
|
static int outdir_offset;
|
2006-05-05 01:33:05 +00:00
|
|
|
|
2016-06-22 15:01:59 +00:00
|
|
|
static int open_next_file(struct commit *commit, const char *subject,
|
2012-05-21 23:10:32 +00:00
|
|
|
struct rev_info *rev, int quiet)
|
2006-05-04 23:16:40 +00:00
|
|
|
{
|
2009-03-23 02:14:03 +00:00
|
|
|
struct strbuf filename = STRBUF_INIT;
|
2012-12-22 06:24:03 +00:00
|
|
|
int suffix_len = strlen(rev->patch_suffix) + 1;
|
2006-05-04 23:16:40 +00:00
|
|
|
|
2006-05-05 01:33:32 +00:00
|
|
|
if (output_directory) {
|
2009-03-23 02:14:03 +00:00
|
|
|
strbuf_addstr(&filename, output_directory);
|
|
|
|
if (filename.len >=
|
|
|
|
PATH_MAX - FORMAT_PATCH_NAME_MAX - suffix_len)
|
2011-02-22 23:41:57 +00:00
|
|
|
return error(_("name of output directory is too long"));
|
use strbuf_complete to conditionally append slash
When working with paths in strbufs, we frequently want to
ensure that a directory contains a trailing slash before
appending to it. We can shorten this code (and make the
intent more obvious) by calling strbuf_complete.
Most of these cases are trivially identical conversions, but
there are two things to note:
- in a few cases we did not check that the strbuf is
non-empty (which would lead to an out-of-bounds memory
access). These were generally not triggerable in
practice, either from earlier assertions, or typically
because we would have just fed the strbuf to opendir(),
which would choke on an empty path.
- in a few cases we indexed the buffer with "original_len"
or similar, rather than the current sb->len, and it is
not immediately obvious from the diff that they are the
same. In all of these cases, I manually verified that
the strbuf does not change between the assignment and
the strbuf_complete call.
This does not convert cases which look like:
if (sb->len && !is_dir_sep(sb->buf[sb->len - 1]))
strbuf_addch(sb, '/');
as those are obviously semantically different. Some of these
cases arguably should be doing that, but that is out of
scope for this change, which aims purely for cleanup with no
behavior change (and at least it will make such sites easier
to find and examine in the future, as we can grep for
strbuf_complete).
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2015-09-24 21:08:35 +00:00
|
|
|
strbuf_complete(&filename, '/');
|
2006-05-05 01:33:32 +00:00
|
|
|
}
|
2006-05-04 23:16:40 +00:00
|
|
|
|
2012-12-22 05:39:37 +00:00
|
|
|
if (rev->numbered_files)
|
|
|
|
strbuf_addf(&filename, "%d", rev->nr);
|
2012-12-22 06:06:01 +00:00
|
|
|
else if (commit)
|
|
|
|
fmt_output_commit(&filename, commit, rev);
|
2012-12-22 05:39:37 +00:00
|
|
|
else
|
2012-12-22 06:06:01 +00:00
|
|
|
fmt_output_subject(&filename, subject, rev);
|
2007-06-05 20:06:53 +00:00
|
|
|
|
2011-04-12 15:35:38 +00:00
|
|
|
if (!quiet)
|
2016-06-22 15:02:04 +00:00
|
|
|
printf("%s\n", filename.buf + outdir_offset);
|
2009-03-18 17:00:45 +00:00
|
|
|
|
2016-06-22 15:01:59 +00:00
|
|
|
if ((rev->diffopt.file = fopen(filename.buf, "w")) == NULL)
|
2011-02-22 23:41:57 +00:00
|
|
|
return error(_("Cannot open patch file %s"), filename.buf);
|
2007-02-23 22:27:58 +00:00
|
|
|
|
2009-03-23 02:14:03 +00:00
|
|
|
strbuf_release(&filename);
|
2007-06-05 20:06:53 +00:00
|
|
|
return 0;
|
2006-05-04 23:16:40 +00:00
|
|
|
}
|
|
|
|
|
2012-07-27 17:21:38 +00:00
|
|
|
static void get_patch_ids(struct rev_info *rev, struct patch_ids *ids)
|
2006-06-25 01:52:01 +00:00
|
|
|
{
|
|
|
|
struct rev_info check_rev;
|
2015-06-01 17:44:21 +00:00
|
|
|
struct commit *commit, *c1, *c2;
|
2006-06-25 01:52:01 +00:00
|
|
|
struct object *o1, *o2;
|
|
|
|
unsigned flags1, flags2;
|
|
|
|
|
|
|
|
if (rev->pending.nr != 2)
|
2011-02-22 23:41:57 +00:00
|
|
|
die(_("Need exactly one range."));
|
2006-06-25 01:52:01 +00:00
|
|
|
|
|
|
|
o1 = rev->pending.objects[0].item;
|
|
|
|
o2 = rev->pending.objects[1].item;
|
2015-06-01 17:44:21 +00:00
|
|
|
flags1 = o1->flags;
|
2006-06-25 01:52:01 +00:00
|
|
|
flags2 = o2->flags;
|
2015-11-10 02:22:29 +00:00
|
|
|
c1 = lookup_commit_reference(o1->oid.hash);
|
|
|
|
c2 = lookup_commit_reference(o2->oid.hash);
|
2006-06-25 01:52:01 +00:00
|
|
|
|
|
|
|
if ((flags1 & UNINTERESTING) == (flags2 & UNINTERESTING))
|
2011-02-22 23:41:57 +00:00
|
|
|
die(_("Not a range."));
|
2006-06-25 01:52:01 +00:00
|
|
|
|
2007-04-10 00:01:27 +00:00
|
|
|
init_patch_ids(ids);
|
2006-06-25 01:52:01 +00:00
|
|
|
|
|
|
|
/* given a range a..b get all patch ids for b..a */
|
2012-07-27 17:21:38 +00:00
|
|
|
init_revisions(&check_rev, rev->prefix);
|
2012-07-29 23:25:36 +00:00
|
|
|
check_rev.max_parents = 1;
|
2006-06-25 01:52:01 +00:00
|
|
|
o1->flags ^= UNINTERESTING;
|
|
|
|
o2->flags ^= UNINTERESTING;
|
|
|
|
add_pending_object(&check_rev, o1, "o1");
|
|
|
|
add_pending_object(&check_rev, o2, "o2");
|
2008-02-18 07:31:56 +00:00
|
|
|
if (prepare_revision_walk(&check_rev))
|
2011-02-22 23:41:57 +00:00
|
|
|
die(_("revision walk setup failed"));
|
2006-06-25 01:52:01 +00:00
|
|
|
|
|
|
|
while ((commit = get_revision(&check_rev)) != NULL) {
|
2007-04-10 00:01:27 +00:00
|
|
|
add_commit_patch_id(commit, ids);
|
2006-06-25 01:52:01 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* reset for next revision walk */
|
2015-06-01 17:44:21 +00:00
|
|
|
clear_commit_marks(c1, SEEN | UNINTERESTING | SHOWN | ADDED);
|
|
|
|
clear_commit_marks(c2, SEEN | UNINTERESTING | SHOWN | ADDED);
|
2006-06-25 01:52:01 +00:00
|
|
|
o1->flags = flags1;
|
|
|
|
o2->flags = flags2;
|
|
|
|
}
|
|
|
|
|
2008-02-19 03:56:06 +00:00
|
|
|
static void gen_message_id(struct rev_info *info, char *base)
|
2006-07-15 00:48:51 +00:00
|
|
|
{
|
2008-10-09 19:12:12 +00:00
|
|
|
struct strbuf buf = STRBUF_INIT;
|
2012-05-21 23:10:08 +00:00
|
|
|
strbuf_addf(&buf, "%s.%lu.git.%s", base,
|
2012-05-24 23:28:25 +00:00
|
|
|
(unsigned long) time(NULL),
|
2012-05-24 23:32:52 +00:00
|
|
|
git_committer_info(IDENT_NO_NAME|IDENT_NO_DATE|IDENT_STRICT));
|
2008-02-19 03:56:06 +00:00
|
|
|
info->message_id = strbuf_detach(&buf, NULL);
|
2006-07-15 00:48:51 +00:00
|
|
|
}
|
|
|
|
|
2016-06-22 15:01:59 +00:00
|
|
|
static void print_signature(FILE *file)
|
2010-06-16 05:59:25 +00:00
|
|
|
{
|
2014-05-21 21:07:51 +00:00
|
|
|
if (!signature || !*signature)
|
|
|
|
return;
|
|
|
|
|
2016-06-22 15:01:59 +00:00
|
|
|
fprintf(file, "-- \n%s", signature);
|
2014-05-21 21:07:51 +00:00
|
|
|
if (signature[strlen(signature)-1] != '\n')
|
2016-06-22 15:01:59 +00:00
|
|
|
putc('\n', file);
|
|
|
|
putc('\n', file);
|
2010-06-16 05:59:25 +00:00
|
|
|
}
|
|
|
|
|
2011-09-22 03:32:28 +00:00
|
|
|
static void add_branch_description(struct strbuf *buf, const char *branch_name)
|
|
|
|
{
|
|
|
|
struct strbuf desc = STRBUF_INIT;
|
|
|
|
if (!branch_name || !*branch_name)
|
|
|
|
return;
|
|
|
|
read_branch_desc(&desc, branch_name);
|
|
|
|
if (desc.len) {
|
|
|
|
strbuf_addch(buf, '\n');
|
2014-07-10 08:52:21 +00:00
|
|
|
strbuf_addbuf(buf, &desc);
|
2011-09-22 03:32:28 +00:00
|
|
|
strbuf_addch(buf, '\n');
|
|
|
|
}
|
2014-08-07 17:13:37 +00:00
|
|
|
strbuf_release(&desc);
|
2011-09-22 03:32:28 +00:00
|
|
|
}
|
|
|
|
|
2013-04-07 17:46:24 +00:00
|
|
|
static char *find_branch_name(struct rev_info *rev)
|
|
|
|
{
|
|
|
|
int i, positive = -1;
|
2015-11-10 02:22:28 +00:00
|
|
|
struct object_id branch_oid;
|
|
|
|
const struct object_id *tip_oid;
|
2014-06-18 19:48:29 +00:00
|
|
|
const char *ref, *v;
|
2013-04-07 17:46:24 +00:00
|
|
|
char *full_ref, *branch = NULL;
|
|
|
|
|
|
|
|
for (i = 0; i < rev->cmdline.nr; i++) {
|
|
|
|
if (rev->cmdline.rev[i].flags & UNINTERESTING)
|
|
|
|
continue;
|
|
|
|
if (positive < 0)
|
|
|
|
positive = i;
|
|
|
|
else
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
if (positive < 0)
|
|
|
|
return NULL;
|
|
|
|
ref = rev->cmdline.rev[positive].name;
|
2015-11-10 02:22:28 +00:00
|
|
|
tip_oid = &rev->cmdline.rev[positive].item->oid;
|
|
|
|
if (dwim_ref(ref, strlen(ref), branch_oid.hash, &full_ref) &&
|
2014-06-18 19:48:29 +00:00
|
|
|
skip_prefix(full_ref, "refs/heads/", &v) &&
|
2015-11-10 02:22:28 +00:00
|
|
|
!oidcmp(tip_oid, &branch_oid))
|
2014-06-18 19:48:29 +00:00
|
|
|
branch = xstrdup(v);
|
2013-04-07 17:46:24 +00:00
|
|
|
free(full_ref);
|
|
|
|
return branch;
|
|
|
|
}
|
|
|
|
|
2008-02-25 23:24:17 +00:00
|
|
|
static void make_cover_letter(struct rev_info *rev, int use_stdout,
|
|
|
|
struct commit *origin,
|
2013-04-07 17:46:24 +00:00
|
|
|
int nr, struct commit **list,
|
2011-09-22 03:32:28 +00:00
|
|
|
const char *branch_name,
|
2011-04-12 15:35:38 +00:00
|
|
|
int quiet)
|
2008-02-19 03:56:13 +00:00
|
|
|
{
|
|
|
|
const char *committer;
|
|
|
|
const char *body = "*** SUBJECT HERE ***\n\n*** BLURB HERE ***\n";
|
|
|
|
const char *msg;
|
2008-02-25 23:24:17 +00:00
|
|
|
struct shortlog log;
|
2008-10-09 19:12:12 +00:00
|
|
|
struct strbuf sb = STRBUF_INIT;
|
2008-02-25 23:24:17 +00:00
|
|
|
int i;
|
2009-05-18 23:44:39 +00:00
|
|
|
const char *encoding = "UTF-8";
|
2008-02-28 17:14:13 +00:00
|
|
|
struct diff_options opts;
|
2008-03-15 07:09:20 +00:00
|
|
|
int need_8bit_cte = 0;
|
2011-05-26 22:27:49 +00:00
|
|
|
struct pretty_print_context pp = {0};
|
2013-04-07 17:46:24 +00:00
|
|
|
struct commit *head = list[0];
|
2008-02-19 03:56:13 +00:00
|
|
|
|
2016-06-05 04:46:39 +00:00
|
|
|
if (!cmit_fmt_is_mail(rev->commit_format))
|
2011-02-22 23:41:57 +00:00
|
|
|
die(_("Cover letter needs email format"));
|
2008-02-19 03:56:13 +00:00
|
|
|
|
2009-03-23 02:14:03 +00:00
|
|
|
committer = git_committer_info(0);
|
2009-03-23 02:14:02 +00:00
|
|
|
|
2012-05-21 23:10:32 +00:00
|
|
|
if (!use_stdout &&
|
2016-06-22 15:01:59 +00:00
|
|
|
open_next_file(NULL, rev->numbered_files ? NULL : "cover-letter", rev, quiet))
|
2008-02-19 03:56:13 +00:00
|
|
|
return;
|
|
|
|
|
2011-05-26 22:27:49 +00:00
|
|
|
log_write_email_headers(rev, head, &pp.subject, &pp.after_subject,
|
2008-03-15 07:09:20 +00:00
|
|
|
&need_8bit_cte);
|
2008-02-19 03:56:13 +00:00
|
|
|
|
2014-06-10 21:41:51 +00:00
|
|
|
for (i = 0; !need_8bit_cte && i < nr; i++) {
|
2014-06-10 21:44:13 +00:00
|
|
|
const char *buf = get_commit_buffer(list[i], NULL);
|
2014-06-10 21:41:51 +00:00
|
|
|
if (has_non_ascii(buf))
|
2009-08-10 16:22:22 +00:00
|
|
|
need_8bit_cte = 1;
|
2014-06-10 21:41:51 +00:00
|
|
|
unuse_commit_buffer(list[i], buf);
|
|
|
|
}
|
2009-08-10 16:22:22 +00:00
|
|
|
|
2013-04-07 17:46:24 +00:00
|
|
|
if (!branch_name)
|
|
|
|
branch_name = find_branch_name(rev);
|
|
|
|
|
2008-02-19 03:56:13 +00:00
|
|
|
msg = body;
|
2011-05-26 22:27:49 +00:00
|
|
|
pp.fmt = CMIT_FMT_EMAIL;
|
convert "enum date_mode" into a struct
In preparation for adding date modes that may carry extra
information beyond the mode itself, this patch converts the
date_mode enum into a struct.
Most of the conversion is fairly straightforward; we pass
the struct as a pointer and dereference the type field where
necessary. Locations that declare a date_mode can use a "{}"
constructor. However, the tricky case is where we use the
enum labels as constants, like:
show_date(t, tz, DATE_NORMAL);
Ideally we could say:
show_date(t, tz, &{ DATE_NORMAL });
but of course C does not allow that. Likewise, we cannot
cast the constant to a struct, because we need to pass an
actual address. Our options are basically:
1. Manually add a "struct date_mode d = { DATE_NORMAL }"
definition to each caller, and pass "&d". This makes
the callers uglier, because they sometimes do not even
have their own scope (e.g., they are inside a switch
statement).
2. Provide a pre-made global "date_normal" struct that can
be passed by address. We'd also need "date_rfc2822",
"date_iso8601", and so forth. But at least the ugliness
is defined in one place.
3. Provide a wrapper that generates the correct struct on
the fly. The big downside is that we end up pointing to
a single global, which makes our wrapper non-reentrant.
But show_date is already not reentrant, so it does not
matter.
This patch implements 3, along with a minor macro to keep
the size of the callers sane.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2015-06-25 16:55:02 +00:00
|
|
|
pp.date_mode.type = DATE_RFC2822;
|
2011-05-26 22:27:49 +00:00
|
|
|
pp_user_info(&pp, NULL, &sb, committer, encoding);
|
|
|
|
pp_title_line(&pp, &msg, &sb, encoding, need_8bit_cte);
|
|
|
|
pp_remainder(&pp, &msg, &sb, 0);
|
2011-09-22 03:32:28 +00:00
|
|
|
add_branch_description(&sb, branch_name);
|
2016-06-22 15:01:59 +00:00
|
|
|
fprintf(rev->diffopt.file, "%s\n", sb.buf);
|
2008-02-19 03:56:13 +00:00
|
|
|
|
|
|
|
strbuf_release(&sb);
|
|
|
|
|
2008-02-25 23:24:17 +00:00
|
|
|
shortlog_init(&log);
|
2008-03-02 15:53:39 +00:00
|
|
|
log.wrap_lines = 1;
|
|
|
|
log.wrap = 72;
|
|
|
|
log.in1 = 2;
|
|
|
|
log.in2 = 4;
|
2016-06-22 15:01:59 +00:00
|
|
|
log.file = rev->diffopt.file;
|
2008-02-25 23:24:17 +00:00
|
|
|
for (i = 0; i < nr; i++)
|
|
|
|
shortlog_add_commit(&log, list[i]);
|
|
|
|
|
|
|
|
shortlog_output(&log);
|
|
|
|
|
2008-02-19 03:56:13 +00:00
|
|
|
/*
|
2008-02-25 23:24:17 +00:00
|
|
|
* We can only do diffstat with a unique reference point
|
2008-02-19 03:56:13 +00:00
|
|
|
*/
|
|
|
|
if (!origin)
|
|
|
|
return;
|
|
|
|
|
2008-03-02 15:53:04 +00:00
|
|
|
memcpy(&opts, &rev->diffopt, sizeof(opts));
|
|
|
|
opts.output_format = DIFF_FORMAT_SUMMARY | DIFF_FORMAT_DIFFSTAT;
|
2008-02-19 03:56:13 +00:00
|
|
|
|
2008-02-28 17:14:13 +00:00
|
|
|
diff_setup_done(&opts);
|
|
|
|
|
2015-11-10 02:22:29 +00:00
|
|
|
diff_tree_sha1(origin->tree->object.oid.hash,
|
|
|
|
head->tree->object.oid.hash,
|
2008-02-28 17:14:13 +00:00
|
|
|
"", &opts);
|
|
|
|
diffcore_std(&opts);
|
|
|
|
diff_flush(&opts);
|
2008-02-19 03:56:13 +00:00
|
|
|
|
2016-06-22 15:01:59 +00:00
|
|
|
fprintf(rev->diffopt.file, "\n");
|
2006-07-15 00:48:51 +00:00
|
|
|
}
|
|
|
|
|
2007-09-14 05:30:45 +00:00
|
|
|
static const char *clean_message_id(const char *msg_id)
|
|
|
|
{
|
|
|
|
char ch;
|
|
|
|
const char *a, *z, *m;
|
|
|
|
|
|
|
|
m = msg_id;
|
|
|
|
while ((ch = *m) && (isspace(ch) || (ch == '<')))
|
|
|
|
m++;
|
|
|
|
a = m;
|
|
|
|
z = NULL;
|
|
|
|
while ((ch = *m)) {
|
|
|
|
if (!isspace(ch) && (ch != '>'))
|
|
|
|
z = m;
|
|
|
|
m++;
|
|
|
|
}
|
|
|
|
if (!z)
|
2011-02-22 23:41:57 +00:00
|
|
|
die(_("insane in-reply-to: %s"), msg_id);
|
2007-09-14 05:30:45 +00:00
|
|
|
if (++z == m)
|
|
|
|
return a;
|
2007-09-15 22:32:36 +00:00
|
|
|
return xmemdupz(a, z - a);
|
2007-09-14 05:30:45 +00:00
|
|
|
}
|
|
|
|
|
2009-01-12 23:18:02 +00:00
|
|
|
static const char *set_outdir(const char *prefix, const char *output_directory)
|
|
|
|
{
|
|
|
|
if (output_directory && is_absolute_path(output_directory))
|
|
|
|
return output_directory;
|
|
|
|
|
|
|
|
if (!prefix || !*prefix) {
|
|
|
|
if (output_directory)
|
|
|
|
return output_directory;
|
|
|
|
/* The user did not explicitly ask for "./" */
|
|
|
|
outdir_offset = 2;
|
|
|
|
return "./";
|
|
|
|
}
|
|
|
|
|
|
|
|
outdir_offset = strlen(prefix);
|
|
|
|
if (!output_directory)
|
|
|
|
return prefix;
|
|
|
|
|
|
|
|
return xstrdup(prefix_filename(prefix, outdir_offset,
|
|
|
|
output_directory));
|
|
|
|
}
|
|
|
|
|
2009-05-16 09:24:46 +00:00
|
|
|
static const char * const builtin_format_patch_usage[] = {
|
2015-01-13 07:44:47 +00:00
|
|
|
N_("git format-patch [<options>] [<since> | <revision-range>]"),
|
2009-05-16 09:24:46 +00:00
|
|
|
NULL
|
|
|
|
};
|
|
|
|
|
|
|
|
static int keep_subject = 0;
|
|
|
|
|
|
|
|
static int keep_callback(const struct option *opt, const char *arg, int unset)
|
|
|
|
{
|
|
|
|
((struct rev_info *)opt->value)->total = -1;
|
|
|
|
keep_subject = 1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int subject_prefix = 0;
|
|
|
|
|
|
|
|
static int subject_prefix_callback(const struct option *opt, const char *arg,
|
|
|
|
int unset)
|
|
|
|
{
|
|
|
|
subject_prefix = 1;
|
|
|
|
((struct rev_info *)opt->value)->subject_prefix = arg;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-05-31 23:17:31 +00:00
|
|
|
static int numbered_cmdline_opt = 0;
|
|
|
|
|
2009-05-16 09:24:46 +00:00
|
|
|
static int numbered_callback(const struct option *opt, const char *arg,
|
|
|
|
int unset)
|
|
|
|
{
|
2009-05-31 23:17:31 +00:00
|
|
|
*(int *)opt->value = numbered_cmdline_opt = unset ? 0 : 1;
|
2009-05-16 09:24:46 +00:00
|
|
|
if (unset)
|
|
|
|
auto_number = 0;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int no_numbered_callback(const struct option *opt, const char *arg,
|
|
|
|
int unset)
|
|
|
|
{
|
|
|
|
return numbered_callback(opt, arg, 1);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int output_directory_callback(const struct option *opt, const char *arg,
|
|
|
|
int unset)
|
|
|
|
{
|
|
|
|
const char **dir = (const char **)opt->value;
|
|
|
|
if (*dir)
|
2011-02-22 23:41:57 +00:00
|
|
|
die(_("Two output directories?"));
|
2009-05-16 09:24:46 +00:00
|
|
|
*dir = arg;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int thread_callback(const struct option *opt, const char *arg, int unset)
|
|
|
|
{
|
|
|
|
int *thread = (int *)opt->value;
|
|
|
|
if (unset)
|
|
|
|
*thread = 0;
|
|
|
|
else if (!arg || !strcmp(arg, "shallow"))
|
|
|
|
*thread = THREAD_SHALLOW;
|
|
|
|
else if (!strcmp(arg, "deep"))
|
|
|
|
*thread = THREAD_DEEP;
|
|
|
|
else
|
|
|
|
return 1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int attach_callback(const struct option *opt, const char *arg, int unset)
|
|
|
|
{
|
|
|
|
struct rev_info *rev = (struct rev_info *)opt->value;
|
|
|
|
if (unset)
|
|
|
|
rev->mime_boundary = NULL;
|
|
|
|
else if (arg)
|
|
|
|
rev->mime_boundary = arg;
|
|
|
|
else
|
|
|
|
rev->mime_boundary = git_version_string;
|
|
|
|
rev->no_inline = unset ? 0 : 1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int inline_callback(const struct option *opt, const char *arg, int unset)
|
|
|
|
{
|
|
|
|
struct rev_info *rev = (struct rev_info *)opt->value;
|
|
|
|
if (unset)
|
|
|
|
rev->mime_boundary = NULL;
|
|
|
|
else if (arg)
|
|
|
|
rev->mime_boundary = arg;
|
|
|
|
else
|
|
|
|
rev->mime_boundary = git_version_string;
|
|
|
|
rev->no_inline = 0;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int header_callback(const struct option *opt, const char *arg, int unset)
|
|
|
|
{
|
2010-03-07 22:46:47 +00:00
|
|
|
if (unset) {
|
|
|
|
string_list_clear(&extra_hdr, 0);
|
|
|
|
string_list_clear(&extra_to, 0);
|
|
|
|
string_list_clear(&extra_cc, 0);
|
|
|
|
} else {
|
|
|
|
add_header(arg);
|
|
|
|
}
|
2009-05-16 09:24:46 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-02-16 23:39:34 +00:00
|
|
|
static int to_callback(const struct option *opt, const char *arg, int unset)
|
|
|
|
{
|
2010-03-07 22:46:47 +00:00
|
|
|
if (unset)
|
|
|
|
string_list_clear(&extra_to, 0);
|
|
|
|
else
|
2010-06-25 23:41:38 +00:00
|
|
|
string_list_append(&extra_to, arg);
|
2009-05-16 09:24:46 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int cc_callback(const struct option *opt, const char *arg, int unset)
|
|
|
|
{
|
2010-03-07 22:46:47 +00:00
|
|
|
if (unset)
|
|
|
|
string_list_clear(&extra_cc, 0);
|
|
|
|
else
|
2010-06-25 23:41:38 +00:00
|
|
|
string_list_append(&extra_cc, arg);
|
2009-05-16 09:24:46 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
teach format-patch to place other authors into in-body "From"
Format-patch generates emails with the "From" address set to the
author of each patch. If you are going to send the emails, however,
you would want to replace the author identity with yours (if they
are not the same), and bump the author identity to an in-body
header.
Normally this is handled by git-send-email, which does the
transformation before sending out the emails. However, some
workflows may not use send-email (e.g., imap-send, or a custom
script which feeds the mbox to a non-git MUA). They could each
implement this feature themselves, but getting it right is
non-trivial (one must canonicalize the identities by reversing any
RFC2047 encoding or RFC822 quoting of the headers, which has caused
many bugs in send-email over the years).
This patch takes a different approach: it teaches format-patch a
"--from" option which handles the ident check and in-body header
while it is writing out the email. It's much simpler to do at this
level (because we haven't done any quoting yet), and any workflow
based on format-patch can easily turn it on.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-07-03 07:08:22 +00:00
|
|
|
static int from_callback(const struct option *opt, const char *arg, int unset)
|
|
|
|
{
|
|
|
|
char **from = opt->value;
|
|
|
|
|
|
|
|
free(*from);
|
|
|
|
|
|
|
|
if (unset)
|
|
|
|
*from = NULL;
|
|
|
|
else if (arg)
|
|
|
|
*from = xstrdup(arg);
|
|
|
|
else
|
|
|
|
*from = xstrdup(git_committer_info(IDENT_NO_DATE));
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
format-patch: add '--base' option to record base tree info
Maintainers or third party testers may want to know the exact base tree
the patch series applies to. Teach git format-patch a '--base' option
to record the base tree info and append it at the end of the first
message (either the cover letter or the first patch in the series).
The base tree info consists of the "base commit", which is a well-known
commit that is part of the stable part of the project history everybody
else works off of, and zero or more "prerequisite patches", which are
well-known patches in flight that is not yet part of the "base commit"
that need to be applied on top of "base commit" in topological order
before the patches can be applied.
The "base commit" is shown as "base-commit: " followed by the 40-hex of
the commit object name. A "prerequisite patch" is shown as
"prerequisite-patch-id: " followed by the 40-hex "patch id", which can
be obtained by passing the patch through the "git patch-id --stable"
command.
Imagine that on top of the public commit P, you applied well-known
patches X, Y and Z from somebody else, and then built your three-patch
series A, B, C, the history would be like:
---P---X---Y---Z---A---B---C
With "git format-patch --base=P -3 C" (or variants thereof, e.g. with
"--cover-letter" of using "Z..C" instead of "-3 C" to specify the
range), the base tree information block is shown at the end of the
first message the command outputs (either the first patch, or the
cover letter), like this:
base-commit: P
prerequisite-patch-id: X
prerequisite-patch-id: Y
prerequisite-patch-id: Z
Helped-by: Junio C Hamano <gitster@pobox.com>
Helped-by: Wu Fengguang <fengguang.wu@intel.com>
Signed-off-by: Xiaolong Ye <xiaolong.ye@intel.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-04-26 07:51:22 +00:00
|
|
|
struct base_tree_info {
|
|
|
|
struct object_id base_commit;
|
|
|
|
int nr_patch_id, alloc_patch_id;
|
|
|
|
struct object_id *patch_id;
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct commit *get_base_commit(const char *base_commit,
|
|
|
|
struct commit **list,
|
|
|
|
int total)
|
|
|
|
{
|
|
|
|
struct commit *base = NULL;
|
|
|
|
struct commit **rev;
|
|
|
|
int i = 0, rev_nr = 0;
|
|
|
|
|
2016-04-26 07:51:24 +00:00
|
|
|
if (base_commit && strcmp(base_commit, "auto")) {
|
|
|
|
base = lookup_commit_reference_by_name(base_commit);
|
|
|
|
if (!base)
|
|
|
|
die(_("Unknown commit %s"), base_commit);
|
|
|
|
} else if ((base_commit && !strcmp(base_commit, "auto")) || base_auto) {
|
2016-04-26 07:51:23 +00:00
|
|
|
struct branch *curr_branch = branch_get(NULL);
|
|
|
|
const char *upstream = branch_get_upstream(curr_branch, NULL);
|
|
|
|
if (upstream) {
|
|
|
|
struct commit_list *base_list;
|
|
|
|
struct commit *commit;
|
|
|
|
unsigned char sha1[20];
|
|
|
|
|
|
|
|
if (get_sha1(upstream, sha1))
|
|
|
|
die(_("Failed to resolve '%s' as a valid ref."), upstream);
|
|
|
|
commit = lookup_commit_or_die(sha1, "upstream base");
|
|
|
|
base_list = get_merge_bases_many(commit, total, list);
|
|
|
|
/* There should be one and only one merge base. */
|
|
|
|
if (!base_list || base_list->next)
|
|
|
|
die(_("Could not find exact merge base."));
|
|
|
|
base = base_list->item;
|
|
|
|
free_commit_list(base_list);
|
|
|
|
} else {
|
|
|
|
die(_("Failed to get upstream, if you want to record base commit automatically,\n"
|
|
|
|
"please use git branch --set-upstream-to to track a remote branch.\n"
|
|
|
|
"Or you could specify base commit by --base=<base-commit-id> manually."));
|
|
|
|
}
|
|
|
|
}
|
format-patch: add '--base' option to record base tree info
Maintainers or third party testers may want to know the exact base tree
the patch series applies to. Teach git format-patch a '--base' option
to record the base tree info and append it at the end of the first
message (either the cover letter or the first patch in the series).
The base tree info consists of the "base commit", which is a well-known
commit that is part of the stable part of the project history everybody
else works off of, and zero or more "prerequisite patches", which are
well-known patches in flight that is not yet part of the "base commit"
that need to be applied on top of "base commit" in topological order
before the patches can be applied.
The "base commit" is shown as "base-commit: " followed by the 40-hex of
the commit object name. A "prerequisite patch" is shown as
"prerequisite-patch-id: " followed by the 40-hex "patch id", which can
be obtained by passing the patch through the "git patch-id --stable"
command.
Imagine that on top of the public commit P, you applied well-known
patches X, Y and Z from somebody else, and then built your three-patch
series A, B, C, the history would be like:
---P---X---Y---Z---A---B---C
With "git format-patch --base=P -3 C" (or variants thereof, e.g. with
"--cover-letter" of using "Z..C" instead of "-3 C" to specify the
range), the base tree information block is shown at the end of the
first message the command outputs (either the first patch, or the
cover letter), like this:
base-commit: P
prerequisite-patch-id: X
prerequisite-patch-id: Y
prerequisite-patch-id: Z
Helped-by: Junio C Hamano <gitster@pobox.com>
Helped-by: Wu Fengguang <fengguang.wu@intel.com>
Signed-off-by: Xiaolong Ye <xiaolong.ye@intel.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-04-26 07:51:22 +00:00
|
|
|
|
|
|
|
ALLOC_ARRAY(rev, total);
|
|
|
|
for (i = 0; i < total; i++)
|
|
|
|
rev[i] = list[i];
|
|
|
|
|
|
|
|
rev_nr = total;
|
|
|
|
/*
|
|
|
|
* Get merge base through pair-wise computations
|
|
|
|
* and store it in rev[0].
|
|
|
|
*/
|
|
|
|
while (rev_nr > 1) {
|
|
|
|
for (i = 0; i < rev_nr / 2; i++) {
|
|
|
|
struct commit_list *merge_base;
|
|
|
|
merge_base = get_merge_bases(rev[2 * i], rev[2 * i + 1]);
|
|
|
|
if (!merge_base || merge_base->next)
|
|
|
|
die(_("Failed to find exact merge base"));
|
|
|
|
|
|
|
|
rev[i] = merge_base->item;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (rev_nr % 2)
|
|
|
|
rev[i] = rev[2 * i];
|
|
|
|
rev_nr = (rev_nr + 1) / 2;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!in_merge_bases(base, rev[0]))
|
|
|
|
die(_("base commit should be the ancestor of revision list"));
|
|
|
|
|
|
|
|
for (i = 0; i < total; i++) {
|
|
|
|
if (base == list[i])
|
|
|
|
die(_("base commit shouldn't be in revision list"));
|
|
|
|
}
|
|
|
|
|
|
|
|
free(rev);
|
|
|
|
return base;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void prepare_bases(struct base_tree_info *bases,
|
|
|
|
struct commit *base,
|
|
|
|
struct commit **list,
|
|
|
|
int total)
|
|
|
|
{
|
|
|
|
struct commit *commit;
|
|
|
|
struct rev_info revs;
|
|
|
|
struct diff_options diffopt;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
if (!base)
|
|
|
|
return;
|
|
|
|
|
|
|
|
diff_setup(&diffopt);
|
|
|
|
DIFF_OPT_SET(&diffopt, RECURSIVE);
|
|
|
|
diff_setup_done(&diffopt);
|
|
|
|
|
|
|
|
oidcpy(&bases->base_commit, &base->object.oid);
|
|
|
|
|
|
|
|
init_revisions(&revs, NULL);
|
|
|
|
revs.max_parents = 1;
|
|
|
|
revs.topo_order = 1;
|
|
|
|
for (i = 0; i < total; i++) {
|
|
|
|
list[i]->object.flags &= ~UNINTERESTING;
|
|
|
|
add_pending_object(&revs, &list[i]->object, "rev_list");
|
|
|
|
list[i]->util = (void *)1;
|
|
|
|
}
|
|
|
|
base->object.flags |= UNINTERESTING;
|
|
|
|
add_pending_object(&revs, &base->object, "base");
|
|
|
|
|
|
|
|
if (prepare_revision_walk(&revs))
|
|
|
|
die(_("revision walk setup failed"));
|
|
|
|
/*
|
|
|
|
* Traverse the commits list, get prerequisite patch ids
|
|
|
|
* and stuff them in bases structure.
|
|
|
|
*/
|
|
|
|
while ((commit = get_revision(&revs)) != NULL) {
|
|
|
|
unsigned char sha1[20];
|
|
|
|
struct object_id *patch_id;
|
|
|
|
if (commit->util)
|
|
|
|
continue;
|
rebase: avoid computing unnecessary patch IDs
The `rebase` family of Git commands avoid applying patches that were
already integrated upstream. They do that by using the revision walking
option that computes the patch IDs of the two sides of the rebase
(local-only patches vs upstream-only ones) and skipping those local
patches whose patch ID matches one of the upstream ones.
In many cases, this causes unnecessary churn, as already the set of
paths touched by a given commit would suffice to determine that an
upstream patch has no local equivalent.
This hurts performance in particular when there are a lot of upstream
patches, and/or large ones.
Therefore, let's introduce the concept of a "diff-header-only" patch ID,
compare those first, and only evaluate the "full" patch ID lazily.
Please note that in contrast to the "full" patch IDs, those
"diff-header-only" patch IDs are prone to collide with one another, as
adjacent commits frequently touch the very same files. Hence we now
have to be careful to allow multiple hash entries with the same hash.
We accomplish that by using the hashmap_add() function that does not even
test for hash collisions. This also allows us to evaluate the full patch ID
lazily, i.e. only when we found commits with matching diff-header-only
patch IDs.
We add a performance test that demonstrates ~1-6% improvement. In
practice this will depend on various factors such as how many upstream
changes and how big those changes are along with whether file system
caches are cold or warm. As Git's test suite has no way of catching
performance regressions, we also add a regression test that verifies
that the full patch ID computation is skipped when the diff-header-only
computation suffices.
Signed-off-by: Kevin Willford <kcwillford@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-07-29 16:19:20 +00:00
|
|
|
if (commit_patch_id(commit, &diffopt, sha1, 0))
|
format-patch: add '--base' option to record base tree info
Maintainers or third party testers may want to know the exact base tree
the patch series applies to. Teach git format-patch a '--base' option
to record the base tree info and append it at the end of the first
message (either the cover letter or the first patch in the series).
The base tree info consists of the "base commit", which is a well-known
commit that is part of the stable part of the project history everybody
else works off of, and zero or more "prerequisite patches", which are
well-known patches in flight that is not yet part of the "base commit"
that need to be applied on top of "base commit" in topological order
before the patches can be applied.
The "base commit" is shown as "base-commit: " followed by the 40-hex of
the commit object name. A "prerequisite patch" is shown as
"prerequisite-patch-id: " followed by the 40-hex "patch id", which can
be obtained by passing the patch through the "git patch-id --stable"
command.
Imagine that on top of the public commit P, you applied well-known
patches X, Y and Z from somebody else, and then built your three-patch
series A, B, C, the history would be like:
---P---X---Y---Z---A---B---C
With "git format-patch --base=P -3 C" (or variants thereof, e.g. with
"--cover-letter" of using "Z..C" instead of "-3 C" to specify the
range), the base tree information block is shown at the end of the
first message the command outputs (either the first patch, or the
cover letter), like this:
base-commit: P
prerequisite-patch-id: X
prerequisite-patch-id: Y
prerequisite-patch-id: Z
Helped-by: Junio C Hamano <gitster@pobox.com>
Helped-by: Wu Fengguang <fengguang.wu@intel.com>
Signed-off-by: Xiaolong Ye <xiaolong.ye@intel.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-04-26 07:51:22 +00:00
|
|
|
die(_("cannot get patch id"));
|
|
|
|
ALLOC_GROW(bases->patch_id, bases->nr_patch_id + 1, bases->alloc_patch_id);
|
|
|
|
patch_id = bases->patch_id + bases->nr_patch_id;
|
|
|
|
hashcpy(patch_id->hash, sha1);
|
|
|
|
bases->nr_patch_id++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-06-22 15:01:59 +00:00
|
|
|
static void print_bases(struct base_tree_info *bases, FILE *file)
|
format-patch: add '--base' option to record base tree info
Maintainers or third party testers may want to know the exact base tree
the patch series applies to. Teach git format-patch a '--base' option
to record the base tree info and append it at the end of the first
message (either the cover letter or the first patch in the series).
The base tree info consists of the "base commit", which is a well-known
commit that is part of the stable part of the project history everybody
else works off of, and zero or more "prerequisite patches", which are
well-known patches in flight that is not yet part of the "base commit"
that need to be applied on top of "base commit" in topological order
before the patches can be applied.
The "base commit" is shown as "base-commit: " followed by the 40-hex of
the commit object name. A "prerequisite patch" is shown as
"prerequisite-patch-id: " followed by the 40-hex "patch id", which can
be obtained by passing the patch through the "git patch-id --stable"
command.
Imagine that on top of the public commit P, you applied well-known
patches X, Y and Z from somebody else, and then built your three-patch
series A, B, C, the history would be like:
---P---X---Y---Z---A---B---C
With "git format-patch --base=P -3 C" (or variants thereof, e.g. with
"--cover-letter" of using "Z..C" instead of "-3 C" to specify the
range), the base tree information block is shown at the end of the
first message the command outputs (either the first patch, or the
cover letter), like this:
base-commit: P
prerequisite-patch-id: X
prerequisite-patch-id: Y
prerequisite-patch-id: Z
Helped-by: Junio C Hamano <gitster@pobox.com>
Helped-by: Wu Fengguang <fengguang.wu@intel.com>
Signed-off-by: Xiaolong Ye <xiaolong.ye@intel.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-04-26 07:51:22 +00:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
/* Only do this once, either for the cover or for the first one */
|
|
|
|
if (is_null_oid(&bases->base_commit))
|
|
|
|
return;
|
|
|
|
|
|
|
|
/* Show the base commit */
|
2016-09-08 01:12:01 +00:00
|
|
|
fprintf(file, "\nbase-commit: %s\n", oid_to_hex(&bases->base_commit));
|
format-patch: add '--base' option to record base tree info
Maintainers or third party testers may want to know the exact base tree
the patch series applies to. Teach git format-patch a '--base' option
to record the base tree info and append it at the end of the first
message (either the cover letter or the first patch in the series).
The base tree info consists of the "base commit", which is a well-known
commit that is part of the stable part of the project history everybody
else works off of, and zero or more "prerequisite patches", which are
well-known patches in flight that is not yet part of the "base commit"
that need to be applied on top of "base commit" in topological order
before the patches can be applied.
The "base commit" is shown as "base-commit: " followed by the 40-hex of
the commit object name. A "prerequisite patch" is shown as
"prerequisite-patch-id: " followed by the 40-hex "patch id", which can
be obtained by passing the patch through the "git patch-id --stable"
command.
Imagine that on top of the public commit P, you applied well-known
patches X, Y and Z from somebody else, and then built your three-patch
series A, B, C, the history would be like:
---P---X---Y---Z---A---B---C
With "git format-patch --base=P -3 C" (or variants thereof, e.g. with
"--cover-letter" of using "Z..C" instead of "-3 C" to specify the
range), the base tree information block is shown at the end of the
first message the command outputs (either the first patch, or the
cover letter), like this:
base-commit: P
prerequisite-patch-id: X
prerequisite-patch-id: Y
prerequisite-patch-id: Z
Helped-by: Junio C Hamano <gitster@pobox.com>
Helped-by: Wu Fengguang <fengguang.wu@intel.com>
Signed-off-by: Xiaolong Ye <xiaolong.ye@intel.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-04-26 07:51:22 +00:00
|
|
|
|
|
|
|
/* Show the prerequisite patches */
|
|
|
|
for (i = bases->nr_patch_id - 1; i >= 0; i--)
|
2016-06-22 15:01:59 +00:00
|
|
|
fprintf(file, "prerequisite-patch-id: %s\n", oid_to_hex(&bases->patch_id[i]));
|
format-patch: add '--base' option to record base tree info
Maintainers or third party testers may want to know the exact base tree
the patch series applies to. Teach git format-patch a '--base' option
to record the base tree info and append it at the end of the first
message (either the cover letter or the first patch in the series).
The base tree info consists of the "base commit", which is a well-known
commit that is part of the stable part of the project history everybody
else works off of, and zero or more "prerequisite patches", which are
well-known patches in flight that is not yet part of the "base commit"
that need to be applied on top of "base commit" in topological order
before the patches can be applied.
The "base commit" is shown as "base-commit: " followed by the 40-hex of
the commit object name. A "prerequisite patch" is shown as
"prerequisite-patch-id: " followed by the 40-hex "patch id", which can
be obtained by passing the patch through the "git patch-id --stable"
command.
Imagine that on top of the public commit P, you applied well-known
patches X, Y and Z from somebody else, and then built your three-patch
series A, B, C, the history would be like:
---P---X---Y---Z---A---B---C
With "git format-patch --base=P -3 C" (or variants thereof, e.g. with
"--cover-letter" of using "Z..C" instead of "-3 C" to specify the
range), the base tree information block is shown at the end of the
first message the command outputs (either the first patch, or the
cover letter), like this:
base-commit: P
prerequisite-patch-id: X
prerequisite-patch-id: Y
prerequisite-patch-id: Z
Helped-by: Junio C Hamano <gitster@pobox.com>
Helped-by: Wu Fengguang <fengguang.wu@intel.com>
Signed-off-by: Xiaolong Ye <xiaolong.ye@intel.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-04-26 07:51:22 +00:00
|
|
|
|
|
|
|
free(bases->patch_id);
|
|
|
|
bases->nr_patch_id = 0;
|
|
|
|
bases->alloc_patch_id = 0;
|
|
|
|
oidclr(&bases->base_commit);
|
|
|
|
}
|
|
|
|
|
2006-07-29 05:44:25 +00:00
|
|
|
int cmd_format_patch(int argc, const char **argv, const char *prefix)
|
2006-04-21 20:19:58 +00:00
|
|
|
{
|
|
|
|
struct commit *commit;
|
|
|
|
struct commit **list = NULL;
|
|
|
|
struct rev_info rev;
|
2010-03-09 06:58:09 +00:00
|
|
|
struct setup_revision_opt s_r_opt;
|
2009-05-16 09:24:46 +00:00
|
|
|
int nr = 0, total, i;
|
2006-05-04 23:16:40 +00:00
|
|
|
int use_stdout = 0;
|
2006-05-25 21:55:11 +00:00
|
|
|
int start_number = -1;
|
2012-12-22 05:27:38 +00:00
|
|
|
int just_numbers = 0;
|
2006-06-25 01:52:01 +00:00
|
|
|
int ignore_if_in_upstream = 0;
|
2013-04-07 17:46:23 +00:00
|
|
|
int cover_letter = -1;
|
2008-02-25 23:24:17 +00:00
|
|
|
int boundary_count = 0;
|
2008-05-09 22:55:43 +00:00
|
|
|
int no_binary_diff = 0;
|
2015-12-15 01:52:04 +00:00
|
|
|
int zero_commit = 0;
|
2013-04-07 17:46:24 +00:00
|
|
|
struct commit *origin = NULL;
|
2006-07-15 05:47:53 +00:00
|
|
|
const char *in_reply_to = NULL;
|
2007-04-10 00:01:27 +00:00
|
|
|
struct patch_ids ids;
|
2008-10-09 19:12:12 +00:00
|
|
|
struct strbuf buf = STRBUF_INIT;
|
2009-11-04 07:19:40 +00:00
|
|
|
int use_patch_format = 0;
|
2011-04-12 15:35:38 +00:00
|
|
|
int quiet = 0;
|
2012-12-22 08:21:23 +00:00
|
|
|
int reroll_count = -1;
|
2011-09-22 03:32:28 +00:00
|
|
|
char *branch_name = NULL;
|
format-patch: add '--base' option to record base tree info
Maintainers or third party testers may want to know the exact base tree
the patch series applies to. Teach git format-patch a '--base' option
to record the base tree info and append it at the end of the first
message (either the cover letter or the first patch in the series).
The base tree info consists of the "base commit", which is a well-known
commit that is part of the stable part of the project history everybody
else works off of, and zero or more "prerequisite patches", which are
well-known patches in flight that is not yet part of the "base commit"
that need to be applied on top of "base commit" in topological order
before the patches can be applied.
The "base commit" is shown as "base-commit: " followed by the 40-hex of
the commit object name. A "prerequisite patch" is shown as
"prerequisite-patch-id: " followed by the 40-hex "patch id", which can
be obtained by passing the patch through the "git patch-id --stable"
command.
Imagine that on top of the public commit P, you applied well-known
patches X, Y and Z from somebody else, and then built your three-patch
series A, B, C, the history would be like:
---P---X---Y---Z---A---B---C
With "git format-patch --base=P -3 C" (or variants thereof, e.g. with
"--cover-letter" of using "Z..C" instead of "-3 C" to specify the
range), the base tree information block is shown at the end of the
first message the command outputs (either the first patch, or the
cover letter), like this:
base-commit: P
prerequisite-patch-id: X
prerequisite-patch-id: Y
prerequisite-patch-id: Z
Helped-by: Junio C Hamano <gitster@pobox.com>
Helped-by: Wu Fengguang <fengguang.wu@intel.com>
Signed-off-by: Xiaolong Ye <xiaolong.ye@intel.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-04-26 07:51:22 +00:00
|
|
|
char *base_commit = NULL;
|
|
|
|
struct base_tree_info bases;
|
|
|
|
|
2009-05-16 09:24:46 +00:00
|
|
|
const struct option builtin_format_patch_options[] = {
|
|
|
|
{ OPTION_CALLBACK, 'n', "numbered", &numbered, NULL,
|
2012-08-20 12:32:12 +00:00
|
|
|
N_("use [PATCH n/m] even with a single patch"),
|
2009-05-16 09:24:46 +00:00
|
|
|
PARSE_OPT_NOARG, numbered_callback },
|
|
|
|
{ OPTION_CALLBACK, 'N', "no-numbered", &numbered, NULL,
|
2012-08-20 12:32:12 +00:00
|
|
|
N_("use [PATCH] even with multiple patches"),
|
2009-05-16 09:24:46 +00:00
|
|
|
PARSE_OPT_NOARG, no_numbered_callback },
|
2013-04-07 17:46:22 +00:00
|
|
|
OPT_BOOL('s', "signoff", &do_signoff, N_("add Signed-off-by:")),
|
|
|
|
OPT_BOOL(0, "stdout", &use_stdout,
|
2012-08-20 12:32:12 +00:00
|
|
|
N_("print patches to standard out")),
|
2013-04-07 17:46:22 +00:00
|
|
|
OPT_BOOL(0, "cover-letter", &cover_letter,
|
2012-08-20 12:32:12 +00:00
|
|
|
N_("generate a cover letter")),
|
2013-04-07 17:46:22 +00:00
|
|
|
OPT_BOOL(0, "numbered-files", &just_numbers,
|
2012-08-20 12:32:12 +00:00
|
|
|
N_("use simple number sequence for output file names")),
|
|
|
|
OPT_STRING(0, "suffix", &fmt_patch_suffix, N_("sfx"),
|
|
|
|
N_("use <sfx> instead of '.patch'")),
|
2009-05-16 09:24:46 +00:00
|
|
|
OPT_INTEGER(0, "start-number", &start_number,
|
2012-08-20 12:32:12 +00:00
|
|
|
N_("start numbering patches at <n> instead of 1")),
|
2013-01-02 22:19:05 +00:00
|
|
|
OPT_INTEGER('v', "reroll-count", &reroll_count,
|
2012-12-22 08:21:23 +00:00
|
|
|
N_("mark the series as Nth re-roll")),
|
2012-08-20 12:32:12 +00:00
|
|
|
{ OPTION_CALLBACK, 0, "subject-prefix", &rev, N_("prefix"),
|
|
|
|
N_("Use [<prefix>] instead of [PATCH]"),
|
2009-05-16 09:24:46 +00:00
|
|
|
PARSE_OPT_NONEG, subject_prefix_callback },
|
|
|
|
{ OPTION_CALLBACK, 'o', "output-directory", &output_directory,
|
2012-08-20 12:32:12 +00:00
|
|
|
N_("dir"), N_("store resulting files in <dir>"),
|
2009-05-16 09:24:46 +00:00
|
|
|
PARSE_OPT_NONEG, output_directory_callback },
|
|
|
|
{ OPTION_CALLBACK, 'k', "keep-subject", &rev, NULL,
|
2012-08-20 12:32:12 +00:00
|
|
|
N_("don't strip/add [PATCH]"),
|
2009-05-16 09:24:46 +00:00
|
|
|
PARSE_OPT_NOARG | PARSE_OPT_NONEG, keep_callback },
|
2013-08-03 11:51:19 +00:00
|
|
|
OPT_BOOL(0, "no-binary", &no_binary_diff,
|
|
|
|
N_("don't output binary diffs")),
|
2015-12-15 01:52:04 +00:00
|
|
|
OPT_BOOL(0, "zero-commit", &zero_commit,
|
|
|
|
N_("output all-zero hash in From header")),
|
2013-08-03 11:51:19 +00:00
|
|
|
OPT_BOOL(0, "ignore-if-in-upstream", &ignore_if_in_upstream,
|
|
|
|
N_("don't include a patch matching a commit upstream")),
|
2013-08-03 11:51:18 +00:00
|
|
|
{ OPTION_SET_INT, 'p', "no-stat", &use_patch_format, NULL,
|
2012-08-20 12:32:12 +00:00
|
|
|
N_("show patch format instead of default (patch + stat)"),
|
2013-08-03 11:51:18 +00:00
|
|
|
PARSE_OPT_NONEG | PARSE_OPT_NOARG, NULL, 1},
|
2012-08-20 12:32:12 +00:00
|
|
|
OPT_GROUP(N_("Messaging")),
|
|
|
|
{ OPTION_CALLBACK, 0, "add-header", NULL, N_("header"),
|
|
|
|
N_("add email header"), 0, header_callback },
|
|
|
|
{ OPTION_CALLBACK, 0, "to", NULL, N_("email"), N_("add To: header"),
|
2010-03-07 22:46:47 +00:00
|
|
|
0, to_callback },
|
2012-08-20 12:32:12 +00:00
|
|
|
{ OPTION_CALLBACK, 0, "cc", NULL, N_("email"), N_("add Cc: header"),
|
2010-03-07 22:46:47 +00:00
|
|
|
0, cc_callback },
|
teach format-patch to place other authors into in-body "From"
Format-patch generates emails with the "From" address set to the
author of each patch. If you are going to send the emails, however,
you would want to replace the author identity with yours (if they
are not the same), and bump the author identity to an in-body
header.
Normally this is handled by git-send-email, which does the
transformation before sending out the emails. However, some
workflows may not use send-email (e.g., imap-send, or a custom
script which feeds the mbox to a non-git MUA). They could each
implement this feature themselves, but getting it right is
non-trivial (one must canonicalize the identities by reversing any
RFC2047 encoding or RFC822 quoting of the headers, which has caused
many bugs in send-email over the years).
This patch takes a different approach: it teaches format-patch a
"--from" option which handles the ident check and in-body header
while it is writing out the email. It's much simpler to do at this
level (because we haven't done any quoting yet), and any workflow
based on format-patch can easily turn it on.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-07-03 07:08:22 +00:00
|
|
|
{ OPTION_CALLBACK, 0, "from", &from, N_("ident"),
|
|
|
|
N_("set From address to <ident> (or committer ident if absent)"),
|
|
|
|
PARSE_OPT_OPTARG, from_callback },
|
2012-08-20 12:32:12 +00:00
|
|
|
OPT_STRING(0, "in-reply-to", &in_reply_to, N_("message-id"),
|
|
|
|
N_("make first mail a reply to <message-id>")),
|
|
|
|
{ OPTION_CALLBACK, 0, "attach", &rev, N_("boundary"),
|
|
|
|
N_("attach the patch"), PARSE_OPT_OPTARG,
|
2009-05-16 09:24:46 +00:00
|
|
|
attach_callback },
|
2012-08-20 12:32:12 +00:00
|
|
|
{ OPTION_CALLBACK, 0, "inline", &rev, N_("boundary"),
|
|
|
|
N_("inline the patch"),
|
2009-05-16 09:24:46 +00:00
|
|
|
PARSE_OPT_OPTARG | PARSE_OPT_NONEG,
|
|
|
|
inline_callback },
|
2012-08-20 12:32:12 +00:00
|
|
|
{ OPTION_CALLBACK, 0, "thread", &thread, N_("style"),
|
|
|
|
N_("enable message threading, styles: shallow, deep"),
|
2009-05-16 09:24:46 +00:00
|
|
|
PARSE_OPT_OPTARG, thread_callback },
|
2012-08-20 12:32:12 +00:00
|
|
|
OPT_STRING(0, "signature", &signature, N_("signature"),
|
|
|
|
N_("add a signature")),
|
format-patch: add '--base' option to record base tree info
Maintainers or third party testers may want to know the exact base tree
the patch series applies to. Teach git format-patch a '--base' option
to record the base tree info and append it at the end of the first
message (either the cover letter or the first patch in the series).
The base tree info consists of the "base commit", which is a well-known
commit that is part of the stable part of the project history everybody
else works off of, and zero or more "prerequisite patches", which are
well-known patches in flight that is not yet part of the "base commit"
that need to be applied on top of "base commit" in topological order
before the patches can be applied.
The "base commit" is shown as "base-commit: " followed by the 40-hex of
the commit object name. A "prerequisite patch" is shown as
"prerequisite-patch-id: " followed by the 40-hex "patch id", which can
be obtained by passing the patch through the "git patch-id --stable"
command.
Imagine that on top of the public commit P, you applied well-known
patches X, Y and Z from somebody else, and then built your three-patch
series A, B, C, the history would be like:
---P---X---Y---Z---A---B---C
With "git format-patch --base=P -3 C" (or variants thereof, e.g. with
"--cover-letter" of using "Z..C" instead of "-3 C" to specify the
range), the base tree information block is shown at the end of the
first message the command outputs (either the first patch, or the
cover letter), like this:
base-commit: P
prerequisite-patch-id: X
prerequisite-patch-id: Y
prerequisite-patch-id: Z
Helped-by: Junio C Hamano <gitster@pobox.com>
Helped-by: Wu Fengguang <fengguang.wu@intel.com>
Signed-off-by: Xiaolong Ye <xiaolong.ye@intel.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-04-26 07:51:22 +00:00
|
|
|
OPT_STRING(0, "base", &base_commit, N_("base-commit"),
|
|
|
|
N_("add prerequisite tree info to the patch series")),
|
2014-05-24 04:08:14 +00:00
|
|
|
OPT_FILENAME(0, "signature-file", &signature_file,
|
|
|
|
N_("add a signature from a file")),
|
2013-08-03 11:51:20 +00:00
|
|
|
OPT__QUIET(&quiet, N_("don't print the patch filenames")),
|
2009-05-16 09:24:46 +00:00
|
|
|
OPT_END()
|
|
|
|
};
|
2006-04-21 20:19:58 +00:00
|
|
|
|
2010-03-07 22:46:46 +00:00
|
|
|
extra_hdr.strdup_strings = 1;
|
|
|
|
extra_to.strdup_strings = 1;
|
|
|
|
extra_cc.strdup_strings = 1;
|
2016-02-25 08:59:20 +00:00
|
|
|
init_log_defaults();
|
2008-05-14 17:46:53 +00:00
|
|
|
git_config(git_format_config, NULL);
|
2006-07-29 04:21:48 +00:00
|
|
|
init_revisions(&rev, prefix);
|
2006-04-21 20:19:58 +00:00
|
|
|
rev.commit_format = CMIT_FMT_EMAIL;
|
2016-03-29 22:49:24 +00:00
|
|
|
rev.expand_tabs_in_log_default = 0;
|
2006-04-21 20:19:58 +00:00
|
|
|
rev.verbose_header = 1;
|
|
|
|
rev.diff = 1;
|
2011-03-21 10:14:06 +00:00
|
|
|
rev.max_parents = 1;
|
2007-11-10 19:05:14 +00:00
|
|
|
DIFF_OPT_SET(&rev.diffopt, RECURSIVE);
|
2007-07-02 00:48:59 +00:00
|
|
|
rev.subject_prefix = fmt_patch_subject_prefix;
|
2010-03-09 06:58:09 +00:00
|
|
|
memset(&s_r_opt, 0, sizeof(s_r_opt));
|
|
|
|
s_r_opt.def = "HEAD";
|
2012-07-02 19:43:05 +00:00
|
|
|
s_r_opt.revarg_opt = REVARG_COMMITTISH;
|
2006-06-02 13:21:17 +00:00
|
|
|
|
2009-02-12 15:51:55 +00:00
|
|
|
if (default_attach) {
|
|
|
|
rev.mime_boundary = default_attach;
|
|
|
|
rev.no_inline = 1;
|
|
|
|
}
|
|
|
|
|
2006-05-05 01:33:32 +00:00
|
|
|
/*
|
|
|
|
* Parse the arguments before setup_revisions(), or something
|
2007-05-14 14:44:51 +00:00
|
|
|
* like "git format-patch -o a123 HEAD^.." may fail; a123 is
|
2006-05-05 01:33:32 +00:00
|
|
|
* possibly a valid SHA1.
|
|
|
|
*/
|
2009-05-23 18:53:12 +00:00
|
|
|
argc = parse_options(argc, argv, prefix, builtin_format_patch_options,
|
2009-05-16 09:24:46 +00:00
|
|
|
builtin_format_patch_usage,
|
2009-11-26 19:11:59 +00:00
|
|
|
PARSE_OPT_KEEP_ARGV0 | PARSE_OPT_KEEP_UNKNOWN |
|
|
|
|
PARSE_OPT_KEEP_DASHDASH);
|
2006-05-05 01:33:32 +00:00
|
|
|
|
2012-12-22 08:21:23 +00:00
|
|
|
if (0 < reroll_count) {
|
|
|
|
struct strbuf sprefix = STRBUF_INIT;
|
|
|
|
strbuf_addf(&sprefix, "%s v%d",
|
|
|
|
rev.subject_prefix, reroll_count);
|
|
|
|
rev.reroll_count = reroll_count;
|
|
|
|
rev.subject_prefix = strbuf_detach(&sprefix, NULL);
|
|
|
|
}
|
|
|
|
|
2010-03-07 22:46:46 +00:00
|
|
|
for (i = 0; i < extra_hdr.nr; i++) {
|
|
|
|
strbuf_addstr(&buf, extra_hdr.items[i].string);
|
2008-02-19 07:40:33 +00:00
|
|
|
strbuf_addch(&buf, '\n');
|
|
|
|
}
|
|
|
|
|
2010-03-07 22:46:46 +00:00
|
|
|
if (extra_to.nr)
|
2008-02-19 07:40:33 +00:00
|
|
|
strbuf_addstr(&buf, "To: ");
|
2010-03-07 22:46:46 +00:00
|
|
|
for (i = 0; i < extra_to.nr; i++) {
|
2008-02-19 07:40:33 +00:00
|
|
|
if (i)
|
|
|
|
strbuf_addstr(&buf, " ");
|
2010-03-07 22:46:46 +00:00
|
|
|
strbuf_addstr(&buf, extra_to.items[i].string);
|
|
|
|
if (i + 1 < extra_to.nr)
|
2008-02-19 07:40:33 +00:00
|
|
|
strbuf_addch(&buf, ',');
|
|
|
|
strbuf_addch(&buf, '\n');
|
|
|
|
}
|
|
|
|
|
2010-03-07 22:46:46 +00:00
|
|
|
if (extra_cc.nr)
|
2008-02-19 07:40:33 +00:00
|
|
|
strbuf_addstr(&buf, "Cc: ");
|
2010-03-07 22:46:46 +00:00
|
|
|
for (i = 0; i < extra_cc.nr; i++) {
|
2008-02-19 07:40:33 +00:00
|
|
|
if (i)
|
|
|
|
strbuf_addstr(&buf, " ");
|
2010-03-07 22:46:46 +00:00
|
|
|
strbuf_addstr(&buf, extra_cc.items[i].string);
|
|
|
|
if (i + 1 < extra_cc.nr)
|
2008-02-19 07:40:33 +00:00
|
|
|
strbuf_addch(&buf, ',');
|
|
|
|
strbuf_addch(&buf, '\n');
|
|
|
|
}
|
|
|
|
|
2009-06-18 17:28:43 +00:00
|
|
|
rev.extra_headers = strbuf_detach(&buf, NULL);
|
2008-02-19 07:40:33 +00:00
|
|
|
|
teach format-patch to place other authors into in-body "From"
Format-patch generates emails with the "From" address set to the
author of each patch. If you are going to send the emails, however,
you would want to replace the author identity with yours (if they
are not the same), and bump the author identity to an in-body
header.
Normally this is handled by git-send-email, which does the
transformation before sending out the emails. However, some
workflows may not use send-email (e.g., imap-send, or a custom
script which feeds the mbox to a non-git MUA). They could each
implement this feature themselves, but getting it right is
non-trivial (one must canonicalize the identities by reversing any
RFC2047 encoding or RFC822 quoting of the headers, which has caused
many bugs in send-email over the years).
This patch takes a different approach: it teaches format-patch a
"--from" option which handles the ident check and in-body header
while it is writing out the email. It's much simpler to do at this
level (because we haven't done any quoting yet), and any workflow
based on format-patch can easily turn it on.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-07-03 07:08:22 +00:00
|
|
|
if (from) {
|
|
|
|
if (split_ident_line(&rev.from_ident, from, strlen(from)))
|
|
|
|
die(_("invalid ident line: %s"), from);
|
|
|
|
}
|
|
|
|
|
2006-05-26 18:30:49 +00:00
|
|
|
if (start_number < 0)
|
2006-05-25 21:55:11 +00:00
|
|
|
start_number = 1;
|
2009-05-09 08:12:01 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* If numbered is set solely due to format.numbered in config,
|
|
|
|
* and it would conflict with --keep-subject (-k) from the
|
|
|
|
* command line, reset "numbered".
|
|
|
|
*/
|
|
|
|
if (numbered && keep_subject && !numbered_cmdline_opt)
|
|
|
|
numbered = 0;
|
|
|
|
|
2006-05-28 16:23:29 +00:00
|
|
|
if (numbered && keep_subject)
|
2011-02-22 23:41:57 +00:00
|
|
|
die (_("-n and -k are mutually exclusive."));
|
2007-04-11 23:58:07 +00:00
|
|
|
if (keep_subject && subject_prefix)
|
2011-02-22 23:41:57 +00:00
|
|
|
die (_("--subject-prefix and -k are mutually exclusive."));
|
2011-05-26 22:28:17 +00:00
|
|
|
rev.preserve_subject = keep_subject;
|
2006-05-05 02:31:29 +00:00
|
|
|
|
2010-03-09 06:58:09 +00:00
|
|
|
argc = setup_revisions(argc, argv, &rev, &s_r_opt);
|
2006-05-05 01:33:32 +00:00
|
|
|
if (argc > 1)
|
2011-02-22 23:41:57 +00:00
|
|
|
die (_("unrecognized argument: %s"), argv[1]);
|
2006-05-04 23:16:40 +00:00
|
|
|
|
2009-11-07 09:51:56 +00:00
|
|
|
if (rev.diffopt.output_format & DIFF_FORMAT_NAME)
|
2011-02-22 23:41:58 +00:00
|
|
|
die(_("--name-only does not make sense"));
|
2009-11-07 09:51:56 +00:00
|
|
|
if (rev.diffopt.output_format & DIFF_FORMAT_NAME_STATUS)
|
2011-02-22 23:41:58 +00:00
|
|
|
die(_("--name-status does not make sense"));
|
2009-11-07 09:51:56 +00:00
|
|
|
if (rev.diffopt.output_format & DIFF_FORMAT_CHECKDIFF)
|
2011-02-22 23:41:58 +00:00
|
|
|
die(_("--check does not make sense"));
|
2009-11-07 09:51:56 +00:00
|
|
|
|
|
|
|
if (!use_patch_format &&
|
|
|
|
(!rev.diffopt.output_format ||
|
|
|
|
rev.diffopt.output_format == DIFF_FORMAT_PATCH))
|
|
|
|
rev.diffopt.output_format = DIFF_FORMAT_DIFFSTAT | DIFF_FORMAT_SUMMARY;
|
|
|
|
|
|
|
|
/* Always generate a patch */
|
|
|
|
rev.diffopt.output_format |= DIFF_FORMAT_PATCH;
|
2006-06-24 17:24:14 +00:00
|
|
|
|
2015-12-15 01:52:04 +00:00
|
|
|
rev.zero_commit = zero_commit;
|
|
|
|
|
2008-05-09 22:55:43 +00:00
|
|
|
if (!DIFF_OPT_TST(&rev.diffopt, TEXT) && !no_binary_diff)
|
2007-11-10 19:05:14 +00:00
|
|
|
DIFF_OPT_SET(&rev.diffopt, BINARY);
|
2007-01-17 22:32:52 +00:00
|
|
|
|
2010-03-12 17:04:26 +00:00
|
|
|
if (rev.show_notes)
|
|
|
|
init_display_notes(&rev.notes_opt);
|
|
|
|
|
2016-01-13 13:20:11 +00:00
|
|
|
if (!output_directory && !use_stdout)
|
|
|
|
output_directory = config_output_directory;
|
|
|
|
|
2009-01-12 23:18:02 +00:00
|
|
|
if (!use_stdout)
|
|
|
|
output_directory = set_outdir(prefix, output_directory);
|
2010-11-23 03:16:30 +00:00
|
|
|
else
|
|
|
|
setup_pager();
|
2006-09-28 19:55:35 +00:00
|
|
|
|
2006-06-06 15:46:23 +00:00
|
|
|
if (output_directory) {
|
format-patch: explicitly switch off color when writing to files
The --color=auto handling is done by seeing if file descriptor 1
(the standard output) is connected to a terminal. format-patch
used freopen() to reuse the standard output stream even when sending
its output to an on-disk file, and this check is appropriate.
In the next step, however, we will stop reusing "FILE *stdout", and
instead start using arbitrary file descriptor obtained by doing an
fopen(3) ourselves. The check --color=auto does will become useless,
as we no longer are writing to the standard output stream.
But then, we do not need to guess to begin with. As argued in the commit
message of 7787570c (format-patch: ignore ui.color, 2011-09-13), we do not
allow the ui.color setting to affect format-patch's output. The only time,
therefore, that we allow color sequences to be written to the output files
is when the user specified the --color=always command-line option explicitly.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-06-22 15:01:54 +00:00
|
|
|
if (rev.diffopt.use_color != GIT_COLOR_ALWAYS)
|
|
|
|
rev.diffopt.use_color = GIT_COLOR_NEVER;
|
2006-06-06 15:46:23 +00:00
|
|
|
if (use_stdout)
|
2011-02-22 23:41:57 +00:00
|
|
|
die(_("standard output, or directory, which one?"));
|
2006-06-06 15:46:23 +00:00
|
|
|
if (mkdir(output_directory, 0777) < 0 && errno != EEXIST)
|
2011-02-22 23:41:57 +00:00
|
|
|
die_errno(_("Could not create directory '%s'"),
|
2009-06-27 15:58:47 +00:00
|
|
|
output_directory);
|
2006-06-06 15:46:23 +00:00
|
|
|
}
|
|
|
|
|
Add "named object array" concept
We've had this notion of a "object_list" for a long time, which eventually
grew a "name" member because some users (notably git-rev-list) wanted to
name each object as it is generated.
That object_list is great for some things, but it isn't all that wonderful
for others, and the "name" member is generally not used by everybody.
This patch splits the users of the object_list array up into two: the
traditional list users, who want the list-like format, and who don't
actually use or want the name. And another class of users that really used
the list as an extensible array, and generally wanted to name the objects.
The patch is fairly straightforward, but it's also biggish. Most of it
really just cleans things up: switching the revision parsing and listing
over to the array makes things like the builtin-diff usage much simpler
(we now see exactly how many members the array has, and we don't get the
objects reversed from the order they were on the command line).
One of the main reasons for doing this at all is that the malloc overhead
of the simple object list was actually pretty high, and the array is just
a lot denser. So this patch brings down memory usage by git-rev-list by
just under 3% (on top of all the other memory use optimizations) on the
mozilla archive.
It does add more lines than it removes, and more importantly, it adds a
whole new infrastructure for maintaining lists of objects, but on the
other hand, the new dynamic array code is pretty obvious. The change to
builtin-diff-tree.c shows a fairly good example of why an array interface
is sometimes more natural, and just much simpler for everybody.
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-06-20 00:42:35 +00:00
|
|
|
if (rev.pending.nr == 1) {
|
2013-04-07 17:46:21 +00:00
|
|
|
int check_head = 0;
|
|
|
|
|
2007-08-28 07:38:48 +00:00
|
|
|
if (rev.max_count < 0 && !rev.show_root_diff) {
|
|
|
|
/*
|
|
|
|
* This is traditional behaviour of "git format-patch
|
|
|
|
* origin" that prepares what the origin side still
|
|
|
|
* does not have.
|
|
|
|
*/
|
2007-01-17 21:35:13 +00:00
|
|
|
rev.pending.objects[0].item->flags |= UNINTERESTING;
|
2007-12-11 18:09:04 +00:00
|
|
|
add_head_to_pending(&rev);
|
2013-04-07 17:46:21 +00:00
|
|
|
check_head = 1;
|
2007-01-17 21:35:13 +00:00
|
|
|
}
|
2007-08-28 07:38:48 +00:00
|
|
|
/*
|
|
|
|
* Otherwise, it is "format-patch -22 HEAD", and/or
|
|
|
|
* "format-patch --root HEAD". The user wants
|
|
|
|
* get_revision() to do the usual traversal.
|
2007-01-17 21:35:13 +00:00
|
|
|
*/
|
2013-04-07 17:46:21 +00:00
|
|
|
|
|
|
|
if (!strcmp(rev.pending.objects[0].name, "HEAD"))
|
|
|
|
check_head = 1;
|
|
|
|
|
|
|
|
if (check_head) {
|
|
|
|
unsigned char sha1[20];
|
2014-06-18 19:48:29 +00:00
|
|
|
const char *ref, *v;
|
2014-07-15 19:59:36 +00:00
|
|
|
ref = resolve_ref_unsafe("HEAD", RESOLVE_REF_READING,
|
|
|
|
sha1, NULL);
|
2014-06-18 19:48:29 +00:00
|
|
|
if (ref && skip_prefix(ref, "refs/heads/", &v))
|
|
|
|
branch_name = xstrdup(v);
|
2013-04-07 17:46:21 +00:00
|
|
|
else
|
|
|
|
branch_name = xstrdup(""); /* no branch */
|
|
|
|
}
|
2006-05-06 20:56:38 +00:00
|
|
|
}
|
2009-01-10 20:41:33 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* We cannot move this anywhere earlier because we do want to
|
2010-02-04 05:23:18 +00:00
|
|
|
* know if --root was given explicitly from the command line.
|
2009-01-10 20:41:33 +00:00
|
|
|
*/
|
|
|
|
rev.show_root_diff = 1;
|
|
|
|
|
2010-03-30 02:46:38 +00:00
|
|
|
if (ignore_if_in_upstream) {
|
|
|
|
/* Don't say anything if head and upstream are the same. */
|
|
|
|
if (rev.pending.nr == 2) {
|
|
|
|
struct object_array_entry *o = rev.pending.objects;
|
2015-11-10 02:22:28 +00:00
|
|
|
if (oidcmp(&o[0].item->oid, &o[1].item->oid) == 0)
|
2010-03-30 02:46:38 +00:00
|
|
|
return 0;
|
|
|
|
}
|
2012-07-27 17:21:38 +00:00
|
|
|
get_patch_ids(&rev, &ids);
|
2010-03-30 02:46:38 +00:00
|
|
|
}
|
2006-06-25 01:52:01 +00:00
|
|
|
|
2008-02-18 07:31:56 +00:00
|
|
|
if (prepare_revision_walk(&rev))
|
2011-02-22 23:41:57 +00:00
|
|
|
die(_("revision walk setup failed"));
|
2008-02-25 23:24:17 +00:00
|
|
|
rev.boundary = 1;
|
2006-04-21 20:19:58 +00:00
|
|
|
while ((commit = get_revision(&rev)) != NULL) {
|
2008-02-25 23:24:17 +00:00
|
|
|
if (commit->object.flags & BOUNDARY) {
|
|
|
|
boundary_count++;
|
|
|
|
origin = (boundary_count == 1) ? commit : NULL;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2015-08-20 22:51:45 +00:00
|
|
|
if (ignore_if_in_upstream && has_commit_patch_id(commit, &ids))
|
2006-06-25 01:52:01 +00:00
|
|
|
continue;
|
|
|
|
|
2006-04-21 20:19:58 +00:00
|
|
|
nr++;
|
2014-09-16 18:56:57 +00:00
|
|
|
REALLOC_ARRAY(list, nr);
|
2006-04-21 20:19:58 +00:00
|
|
|
list[nr - 1] = commit;
|
|
|
|
}
|
2013-04-07 17:46:20 +00:00
|
|
|
if (nr == 0)
|
|
|
|
/* nothing to do */
|
|
|
|
return 0;
|
2006-05-04 23:16:40 +00:00
|
|
|
total = nr;
|
2007-11-04 03:38:24 +00:00
|
|
|
if (!keep_subject && auto_number && total > 1)
|
|
|
|
numbered = 1;
|
2006-05-05 02:30:52 +00:00
|
|
|
if (numbered)
|
2006-05-25 21:55:11 +00:00
|
|
|
rev.total = total + start_number - 1;
|
2013-04-07 17:46:23 +00:00
|
|
|
if (cover_letter == -1) {
|
|
|
|
if (config_cover_letter == COVER_AUTO)
|
|
|
|
cover_letter = (total > 1);
|
|
|
|
else
|
|
|
|
cover_letter = (config_cover_letter == COVER_ON);
|
|
|
|
}
|
|
|
|
|
2014-05-24 04:08:14 +00:00
|
|
|
if (!signature) {
|
|
|
|
; /* --no-signature inhibits all signatures */
|
|
|
|
} else if (signature && signature != git_version_string) {
|
|
|
|
; /* non-default signature already set */
|
|
|
|
} else if (signature_file) {
|
|
|
|
struct strbuf buf = STRBUF_INIT;
|
|
|
|
|
|
|
|
if (strbuf_read_file(&buf, signature_file, 128) < 0)
|
|
|
|
die_errno(_("unable to read signature file '%s'"), signature_file);
|
|
|
|
signature = strbuf_detach(&buf, NULL);
|
|
|
|
}
|
|
|
|
|
format-patch: add '--base' option to record base tree info
Maintainers or third party testers may want to know the exact base tree
the patch series applies to. Teach git format-patch a '--base' option
to record the base tree info and append it at the end of the first
message (either the cover letter or the first patch in the series).
The base tree info consists of the "base commit", which is a well-known
commit that is part of the stable part of the project history everybody
else works off of, and zero or more "prerequisite patches", which are
well-known patches in flight that is not yet part of the "base commit"
that need to be applied on top of "base commit" in topological order
before the patches can be applied.
The "base commit" is shown as "base-commit: " followed by the 40-hex of
the commit object name. A "prerequisite patch" is shown as
"prerequisite-patch-id: " followed by the 40-hex "patch id", which can
be obtained by passing the patch through the "git patch-id --stable"
command.
Imagine that on top of the public commit P, you applied well-known
patches X, Y and Z from somebody else, and then built your three-patch
series A, B, C, the history would be like:
---P---X---Y---Z---A---B---C
With "git format-patch --base=P -3 C" (or variants thereof, e.g. with
"--cover-letter" of using "Z..C" instead of "-3 C" to specify the
range), the base tree information block is shown at the end of the
first message the command outputs (either the first patch, or the
cover letter), like this:
base-commit: P
prerequisite-patch-id: X
prerequisite-patch-id: Y
prerequisite-patch-id: Z
Helped-by: Junio C Hamano <gitster@pobox.com>
Helped-by: Wu Fengguang <fengguang.wu@intel.com>
Signed-off-by: Xiaolong Ye <xiaolong.ye@intel.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-04-26 07:51:22 +00:00
|
|
|
memset(&bases, 0, sizeof(bases));
|
2016-04-26 07:51:24 +00:00
|
|
|
if (base_commit || base_auto) {
|
format-patch: add '--base' option to record base tree info
Maintainers or third party testers may want to know the exact base tree
the patch series applies to. Teach git format-patch a '--base' option
to record the base tree info and append it at the end of the first
message (either the cover letter or the first patch in the series).
The base tree info consists of the "base commit", which is a well-known
commit that is part of the stable part of the project history everybody
else works off of, and zero or more "prerequisite patches", which are
well-known patches in flight that is not yet part of the "base commit"
that need to be applied on top of "base commit" in topological order
before the patches can be applied.
The "base commit" is shown as "base-commit: " followed by the 40-hex of
the commit object name. A "prerequisite patch" is shown as
"prerequisite-patch-id: " followed by the 40-hex "patch id", which can
be obtained by passing the patch through the "git patch-id --stable"
command.
Imagine that on top of the public commit P, you applied well-known
patches X, Y and Z from somebody else, and then built your three-patch
series A, B, C, the history would be like:
---P---X---Y---Z---A---B---C
With "git format-patch --base=P -3 C" (or variants thereof, e.g. with
"--cover-letter" of using "Z..C" instead of "-3 C" to specify the
range), the base tree information block is shown at the end of the
first message the command outputs (either the first patch, or the
cover letter), like this:
base-commit: P
prerequisite-patch-id: X
prerequisite-patch-id: Y
prerequisite-patch-id: Z
Helped-by: Junio C Hamano <gitster@pobox.com>
Helped-by: Wu Fengguang <fengguang.wu@intel.com>
Signed-off-by: Xiaolong Ye <xiaolong.ye@intel.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-04-26 07:51:22 +00:00
|
|
|
struct commit *base = get_base_commit(base_commit, list, nr);
|
|
|
|
reset_revision_walk();
|
|
|
|
prepare_bases(&bases, base, list, nr);
|
|
|
|
}
|
|
|
|
|
2009-02-19 21:26:31 +00:00
|
|
|
if (in_reply_to || thread || cover_letter)
|
|
|
|
rev.ref_message_ids = xcalloc(1, sizeof(struct string_list));
|
|
|
|
if (in_reply_to) {
|
|
|
|
const char *msgid = clean_message_id(in_reply_to);
|
2010-06-25 23:41:38 +00:00
|
|
|
string_list_append(rev.ref_message_ids, msgid);
|
2009-02-19 21:26:31 +00:00
|
|
|
}
|
2012-12-22 05:27:38 +00:00
|
|
|
rev.numbered_files = just_numbers;
|
2009-03-23 02:14:05 +00:00
|
|
|
rev.patch_suffix = fmt_patch_suffix;
|
2008-02-19 03:56:13 +00:00
|
|
|
if (cover_letter) {
|
|
|
|
if (thread)
|
|
|
|
gen_message_id(&rev, "cover");
|
2012-12-22 05:27:38 +00:00
|
|
|
make_cover_letter(&rev, use_stdout,
|
2013-04-07 17:46:24 +00:00
|
|
|
origin, nr, list, branch_name, quiet);
|
2016-06-22 15:01:59 +00:00
|
|
|
print_bases(&bases, rev.diffopt.file);
|
2016-09-08 01:12:01 +00:00
|
|
|
print_signature(rev.diffopt.file);
|
2008-02-19 03:56:13 +00:00
|
|
|
total++;
|
|
|
|
start_number--;
|
|
|
|
}
|
2013-02-12 10:17:38 +00:00
|
|
|
rev.add_signoff = do_signoff;
|
2006-04-21 20:19:58 +00:00
|
|
|
while (0 <= --nr) {
|
|
|
|
int shown;
|
|
|
|
commit = list[nr];
|
2006-05-26 18:30:49 +00:00
|
|
|
rev.nr = total - nr + (start_number - 1);
|
2006-07-15 00:48:51 +00:00
|
|
|
/* Make the second and subsequent mails replies to the first */
|
2006-07-15 00:49:04 +00:00
|
|
|
if (thread) {
|
2008-02-19 03:56:13 +00:00
|
|
|
/* Have we already had a message ID? */
|
2008-02-19 03:56:06 +00:00
|
|
|
if (rev.message_id) {
|
2008-02-19 03:56:13 +00:00
|
|
|
/*
|
2009-02-19 21:26:33 +00:00
|
|
|
* For deep threading: make every mail
|
|
|
|
* a reply to the previous one, no
|
|
|
|
* matter what other options are set.
|
|
|
|
*
|
|
|
|
* For shallow threading:
|
|
|
|
*
|
2009-02-19 21:26:32 +00:00
|
|
|
* Without --cover-letter and
|
|
|
|
* --in-reply-to, make every mail a
|
|
|
|
* reply to the one before.
|
|
|
|
*
|
|
|
|
* With --in-reply-to but no
|
|
|
|
* --cover-letter, make every mail a
|
|
|
|
* reply to the <reply-to>.
|
|
|
|
*
|
|
|
|
* With --cover-letter, make every
|
|
|
|
* mail but the cover letter a reply
|
|
|
|
* to the cover letter. The cover
|
|
|
|
* letter is a reply to the
|
|
|
|
* --in-reply-to, if specified.
|
2008-02-19 03:56:13 +00:00
|
|
|
*/
|
2009-02-19 21:26:33 +00:00
|
|
|
if (thread == THREAD_SHALLOW
|
|
|
|
&& rev.ref_message_ids->nr > 0
|
2009-02-19 21:26:32 +00:00
|
|
|
&& (!cover_letter || rev.nr > 1))
|
2008-02-19 03:56:06 +00:00
|
|
|
free(rev.message_id);
|
|
|
|
else
|
2010-06-25 23:41:38 +00:00
|
|
|
string_list_append(rev.ref_message_ids,
|
|
|
|
rev.message_id);
|
2006-07-15 00:49:04 +00:00
|
|
|
}
|
2015-11-10 02:22:28 +00:00
|
|
|
gen_message_id(&rev, oid_to_hex(&commit->object.oid));
|
2006-07-15 00:48:51 +00:00
|
|
|
}
|
2009-03-23 02:14:02 +00:00
|
|
|
|
2012-05-21 23:10:32 +00:00
|
|
|
if (!use_stdout &&
|
2016-06-22 15:01:59 +00:00
|
|
|
open_next_file(rev.numbered_files ? NULL : commit, NULL, &rev, quiet))
|
2011-02-22 23:41:57 +00:00
|
|
|
die(_("Failed to create output files"));
|
2006-04-21 20:19:58 +00:00
|
|
|
shown = log_tree_commit(&rev, commit);
|
provide a helper to free commit buffer
This converts two lines into one at each caller. But more
importantly, it abstracts the concept of freeing the buffer,
which will make it easier to change later.
Note that we also need to provide a "detach" mechanism for a
tricky case in index-pack. We are passed a buffer for the
object generated by processing the incoming pack. If we are
not using --strict, we just calculate the sha1 on that
buffer and return, leaving the caller to free it. But if we
are using --strict, we actually attach that buffer to an
object, pass the object to the fsck functions, and then
detach the buffer from the object again (so that the caller
can free it as usual). In this case, we don't want to free
the buffer ourselves, but just make sure it is no longer
associated with the commit.
Note that we are making the assumption here that the
attach/detach process does not impact the buffer at all
(e.g., it is never reallocated or modified). That holds true
now, and we have no plans to change that. However, as we
abstract the commit_buffer code, this dependency becomes
less obvious. So when we detach, let's also make sure that
we get back the same buffer that we gave to the
commit_buffer code.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2014-06-12 22:05:37 +00:00
|
|
|
free_commit_buffer(commit);
|
2006-05-26 18:30:49 +00:00
|
|
|
|
|
|
|
/* We put one extra blank line between formatted
|
|
|
|
* patches and this flag is used by log-tree code
|
|
|
|
* to see if it needs to emit a LF before showing
|
|
|
|
* the log; when using one file per patch, we do
|
|
|
|
* not want the extra blank line.
|
|
|
|
*/
|
|
|
|
if (!use_stdout)
|
|
|
|
rev.shown_one = 0;
|
2006-05-20 13:40:29 +00:00
|
|
|
if (shown) {
|
2016-09-08 01:12:01 +00:00
|
|
|
print_bases(&bases, rev.diffopt.file);
|
2006-05-20 13:40:29 +00:00
|
|
|
if (rev.mime_boundary)
|
2016-06-22 15:01:59 +00:00
|
|
|
fprintf(rev.diffopt.file, "\n--%s%s--\n\n\n",
|
2006-05-20 13:40:29 +00:00
|
|
|
mime_boundary_leader,
|
|
|
|
rev.mime_boundary);
|
|
|
|
else
|
2016-06-22 15:01:59 +00:00
|
|
|
print_signature(rev.diffopt.file);
|
2006-05-20 13:40:29 +00:00
|
|
|
}
|
2006-05-04 23:16:40 +00:00
|
|
|
if (!use_stdout)
|
2016-06-22 15:01:59 +00:00
|
|
|
fclose(rev.diffopt.file);
|
2006-04-21 20:19:58 +00:00
|
|
|
}
|
|
|
|
free(list);
|
2011-09-22 03:32:28 +00:00
|
|
|
free(branch_name);
|
2010-03-07 22:46:46 +00:00
|
|
|
string_list_clear(&extra_to, 0);
|
|
|
|
string_list_clear(&extra_cc, 0);
|
|
|
|
string_list_clear(&extra_hdr, 0);
|
2007-04-10 00:01:27 +00:00
|
|
|
if (ignore_if_in_upstream)
|
|
|
|
free_patch_ids(&ids);
|
2006-04-21 20:19:58 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-10-23 23:01:57 +00:00
|
|
|
static int add_pending_commit(const char *arg, struct rev_info *revs, int flags)
|
|
|
|
{
|
|
|
|
unsigned char sha1[20];
|
|
|
|
if (get_sha1(arg, sha1) == 0) {
|
|
|
|
struct commit *commit = lookup_commit_reference(sha1);
|
|
|
|
if (commit) {
|
|
|
|
commit->object.flags |= flags;
|
|
|
|
add_pending_object(revs, &commit->object, arg);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2010-03-20 18:55:27 +00:00
|
|
|
static const char * const cherry_usage[] = {
|
2012-08-20 12:32:00 +00:00
|
|
|
N_("git cherry [-v] [<upstream> [<head> [<limit>]]]"),
|
2010-03-20 18:55:27 +00:00
|
|
|
NULL
|
|
|
|
};
|
|
|
|
|
2011-03-16 07:12:48 +00:00
|
|
|
static void print_commit(char sign, struct commit *commit, int verbose,
|
2016-06-22 15:01:59 +00:00
|
|
|
int abbrev, FILE *file)
|
2011-03-16 07:12:48 +00:00
|
|
|
{
|
|
|
|
if (!verbose) {
|
2016-06-22 15:01:59 +00:00
|
|
|
fprintf(file, "%c %s\n", sign,
|
2015-11-10 02:22:29 +00:00
|
|
|
find_unique_abbrev(commit->object.oid.hash, abbrev));
|
2011-03-16 07:12:48 +00:00
|
|
|
} else {
|
|
|
|
struct strbuf buf = STRBUF_INIT;
|
2011-05-31 19:19:11 +00:00
|
|
|
pp_commit_easy(CMIT_FMT_ONELINE, commit, &buf);
|
2016-06-22 15:01:59 +00:00
|
|
|
fprintf(file, "%c %s %s\n", sign,
|
2015-11-10 02:22:29 +00:00
|
|
|
find_unique_abbrev(commit->object.oid.hash, abbrev),
|
2011-03-16 07:12:48 +00:00
|
|
|
buf.buf);
|
|
|
|
strbuf_release(&buf);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-10-23 23:01:57 +00:00
|
|
|
int cmd_cherry(int argc, const char **argv, const char *prefix)
|
|
|
|
{
|
|
|
|
struct rev_info revs;
|
2007-04-10 00:01:27 +00:00
|
|
|
struct patch_ids ids;
|
2006-10-23 23:01:57 +00:00
|
|
|
struct commit *commit;
|
|
|
|
struct commit_list *list = NULL;
|
2008-12-29 17:45:20 +00:00
|
|
|
struct branch *current_branch;
|
2006-10-23 23:01:57 +00:00
|
|
|
const char *upstream;
|
|
|
|
const char *head = "HEAD";
|
|
|
|
const char *limit = NULL;
|
2010-03-20 18:55:27 +00:00
|
|
|
int verbose = 0, abbrev = 0;
|
2006-10-23 23:01:57 +00:00
|
|
|
|
2010-03-20 18:55:27 +00:00
|
|
|
struct option options[] = {
|
|
|
|
OPT__ABBREV(&abbrev),
|
2012-08-20 12:32:00 +00:00
|
|
|
OPT__VERBOSE(&verbose, N_("be verbose")),
|
2010-03-20 18:55:27 +00:00
|
|
|
OPT_END()
|
|
|
|
};
|
2006-10-23 23:01:57 +00:00
|
|
|
|
2010-03-20 18:55:27 +00:00
|
|
|
argc = parse_options(argc, argv, prefix, options, cherry_usage, 0);
|
2009-11-09 15:04:43 +00:00
|
|
|
|
2006-10-23 23:01:57 +00:00
|
|
|
switch (argc) {
|
|
|
|
case 3:
|
2010-03-20 18:55:27 +00:00
|
|
|
limit = argv[2];
|
2006-10-23 23:01:57 +00:00
|
|
|
/* FALLTHROUGH */
|
|
|
|
case 2:
|
2010-03-20 18:55:27 +00:00
|
|
|
head = argv[1];
|
|
|
|
/* FALLTHROUGH */
|
|
|
|
case 1:
|
|
|
|
upstream = argv[0];
|
2006-10-23 23:01:57 +00:00
|
|
|
break;
|
|
|
|
default:
|
2008-12-29 17:45:20 +00:00
|
|
|
current_branch = branch_get(NULL);
|
2015-05-21 04:45:32 +00:00
|
|
|
upstream = branch_get_upstream(current_branch, NULL);
|
2015-05-21 04:45:28 +00:00
|
|
|
if (!upstream) {
|
2011-02-22 23:41:57 +00:00
|
|
|
fprintf(stderr, _("Could not find a tracked"
|
2008-12-29 17:45:20 +00:00
|
|
|
" remote branch, please"
|
2011-02-22 23:41:57 +00:00
|
|
|
" specify <upstream> manually.\n"));
|
2010-03-20 18:55:27 +00:00
|
|
|
usage_with_options(cherry_usage, options);
|
2008-12-29 17:45:20 +00:00
|
|
|
}
|
2006-10-23 23:01:57 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
init_revisions(&revs, prefix);
|
2012-07-29 23:25:36 +00:00
|
|
|
revs.max_parents = 1;
|
2006-10-23 23:01:57 +00:00
|
|
|
|
|
|
|
if (add_pending_commit(head, &revs, 0))
|
2011-02-22 23:41:57 +00:00
|
|
|
die(_("Unknown commit %s"), head);
|
2006-10-23 23:01:57 +00:00
|
|
|
if (add_pending_commit(upstream, &revs, UNINTERESTING))
|
2011-02-22 23:41:57 +00:00
|
|
|
die(_("Unknown commit %s"), upstream);
|
2006-10-23 23:01:57 +00:00
|
|
|
|
|
|
|
/* Don't say anything if head and upstream are the same. */
|
|
|
|
if (revs.pending.nr == 2) {
|
|
|
|
struct object_array_entry *o = revs.pending.objects;
|
2015-11-10 02:22:28 +00:00
|
|
|
if (oidcmp(&o[0].item->oid, &o[1].item->oid) == 0)
|
2006-10-23 23:01:57 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-07-27 17:21:38 +00:00
|
|
|
get_patch_ids(&revs, &ids);
|
2006-10-23 23:01:57 +00:00
|
|
|
|
|
|
|
if (limit && add_pending_commit(limit, &revs, UNINTERESTING))
|
2011-02-22 23:41:57 +00:00
|
|
|
die(_("Unknown commit %s"), limit);
|
2006-10-23 23:01:57 +00:00
|
|
|
|
|
|
|
/* reverse the list of commits */
|
2008-02-18 07:31:56 +00:00
|
|
|
if (prepare_revision_walk(&revs))
|
2011-02-22 23:41:57 +00:00
|
|
|
die(_("revision walk setup failed"));
|
2006-10-23 23:01:57 +00:00
|
|
|
while ((commit = get_revision(&revs)) != NULL) {
|
|
|
|
commit_list_insert(commit, &list);
|
|
|
|
}
|
|
|
|
|
|
|
|
while (list) {
|
|
|
|
char sign = '+';
|
|
|
|
|
|
|
|
commit = list->item;
|
2007-04-10 00:01:27 +00:00
|
|
|
if (has_commit_patch_id(commit, &ids))
|
2006-10-23 23:01:57 +00:00
|
|
|
sign = '-';
|
2016-06-22 15:01:59 +00:00
|
|
|
print_commit(sign, commit, verbose, abbrev, revs.diffopt.file);
|
2006-10-23 23:01:57 +00:00
|
|
|
list = list->next;
|
|
|
|
}
|
|
|
|
|
2007-04-10 00:01:27 +00:00
|
|
|
free_patch_ids(&ids);
|
2006-10-23 23:01:57 +00:00
|
|
|
return 0;
|
|
|
|
}
|