2006-10-23 23:27:45 +02:00
|
|
|
/*
|
|
|
|
|
* Builtin "git branch"
|
|
|
|
|
*
|
2007-07-12 07:52:45 +02:00
|
|
|
* Copyright (c) 2006 Kristian Høgsberg <krh@redhat.com>
|
2006-10-23 23:27:45 +02:00
|
|
|
* Based on git-branch.sh by Junio C Hamano.
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
#include "cache.h"
|
2006-12-19 23:34:12 +01:00
|
|
|
#include "color.h"
|
2006-10-23 23:27:45 +02:00
|
|
|
#include "refs.h"
|
|
|
|
|
#include "commit.h"
|
|
|
|
|
#include "builtin.h"
|
2007-07-10 19:50:44 +02:00
|
|
|
#include "remote.h"
|
2007-10-07 18:26:21 +02:00
|
|
|
#include "parse-options.h"
|
2008-02-07 17:40:08 +01:00
|
|
|
#include "branch.h"
|
2008-07-24 00:13:41 +02:00
|
|
|
#include "diff.h"
|
|
|
|
|
#include "revision.h"
|
2007-10-07 18:26:21 +02:00
|
|
|
|
|
|
|
|
static const char * const builtin_branch_usage[] = {
|
2008-07-13 15:36:15 +02:00
|
|
|
"git branch [options] [-r | -a] [--merged | --no-merged]",
|
|
|
|
|
"git branch [options] [-l] [-f] <branchname> [<start-point>]",
|
2011-06-28 00:04:32 +02:00
|
|
|
"git branch [options] [-r] (-d | -D) <branchname>...",
|
2008-07-13 15:36:15 +02:00
|
|
|
"git branch [options] (-m | -M) [<oldbranch>] <newbranch>",
|
2007-10-07 18:26:21 +02:00
|
|
|
NULL
|
|
|
|
|
};
|
2006-10-23 23:27:45 +02:00
|
|
|
|
2006-12-18 08:58:16 +01:00
|
|
|
#define REF_LOCAL_BRANCH 0x01
|
|
|
|
|
#define REF_REMOTE_BRANCH 0x02
|
2006-10-23 23:27:45 +02:00
|
|
|
|
|
|
|
|
static const char *head;
|
|
|
|
|
static unsigned char head_sha1[20];
|
|
|
|
|
|
2008-02-18 08:26:03 +01:00
|
|
|
static int branch_use_color = -1;
|
2006-12-12 07:41:52 +01:00
|
|
|
static char branch_colors[][COLOR_MAXLEN] = {
|
2009-02-13 22:53:40 +01:00
|
|
|
GIT_COLOR_RESET,
|
|
|
|
|
GIT_COLOR_NORMAL, /* PLAIN */
|
|
|
|
|
GIT_COLOR_RED, /* REMOTE */
|
|
|
|
|
GIT_COLOR_NORMAL, /* LOCAL */
|
|
|
|
|
GIT_COLOR_GREEN, /* CURRENT */
|
2006-12-12 07:41:52 +01:00
|
|
|
};
|
|
|
|
|
enum color_branch {
|
2009-02-13 22:53:41 +01:00
|
|
|
BRANCH_COLOR_RESET = 0,
|
|
|
|
|
BRANCH_COLOR_PLAIN = 1,
|
|
|
|
|
BRANCH_COLOR_REMOTE = 2,
|
|
|
|
|
BRANCH_COLOR_LOCAL = 3,
|
2010-05-14 11:31:35 +02:00
|
|
|
BRANCH_COLOR_CURRENT = 4
|
2006-12-12 07:41:52 +01:00
|
|
|
};
|
|
|
|
|
|
2008-07-09 02:55:47 +02:00
|
|
|
static enum merge_filter {
|
|
|
|
|
NO_FILTER = 0,
|
|
|
|
|
SHOW_NOT_MERGED,
|
2010-05-14 11:31:35 +02:00
|
|
|
SHOW_MERGED
|
2008-07-09 02:55:47 +02:00
|
|
|
} merge_filter;
|
|
|
|
|
static unsigned char merge_filter_ref[20];
|
2008-04-17 22:24:50 +02:00
|
|
|
|
2006-12-12 07:41:52 +01:00
|
|
|
static int parse_branch_color_slot(const char *var, int ofs)
|
|
|
|
|
{
|
|
|
|
|
if (!strcasecmp(var+ofs, "plain"))
|
2009-02-13 22:53:41 +01:00
|
|
|
return BRANCH_COLOR_PLAIN;
|
2006-12-12 07:41:52 +01:00
|
|
|
if (!strcasecmp(var+ofs, "reset"))
|
2009-02-13 22:53:41 +01:00
|
|
|
return BRANCH_COLOR_RESET;
|
2006-12-12 07:41:52 +01:00
|
|
|
if (!strcasecmp(var+ofs, "remote"))
|
2009-02-13 22:53:41 +01:00
|
|
|
return BRANCH_COLOR_REMOTE;
|
2006-12-12 07:41:52 +01:00
|
|
|
if (!strcasecmp(var+ofs, "local"))
|
2009-02-13 22:53:41 +01:00
|
|
|
return BRANCH_COLOR_LOCAL;
|
2006-12-12 07:41:52 +01:00
|
|
|
if (!strcasecmp(var+ofs, "current"))
|
2009-02-13 22:53:41 +01:00
|
|
|
return BRANCH_COLOR_CURRENT;
|
ignore unknown color configuration
When parsing the config file, if there is a value that is
syntactically correct but unused, we generally ignore it.
This lets non-core porcelains store arbitrary information in
the config file, and it means that configuration files can
be shared between new and old versions of git (the old
versions might simply ignore certain configuration).
The one exception to this is color configuration; if we
encounter a color.{diff,branch,status}.$slot variable, we
die if it is not one of the recognized slots (presumably as
a safety valve for user misconfiguration). This behavior
has existed since 801235c (diff --color: use
$GIT_DIR/config, 2006-06-24), but hasn't yet caused a
problem. No porcelain has wanted to store extra colors, and
we once a color area (like color.diff) has been introduced,
we've never changed the set of color slots.
However, that changed recently with the addition of
color.diff.func. Now a user with color.diff.func in their
config can no longer freely switch between v1.6.6 and older
versions; the old versions will complain about the existence
of the variable.
This patch loosens the check to match the rest of
git-config; unknown color slots are simply ignored. This
doesn't fix this particular problem, as the older version
(without this patch) is the problem, but it at least
prevents it from happening again in the future.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2009-12-12 13:25:24 +01:00
|
|
|
return -1;
|
2006-12-12 07:41:52 +01:00
|
|
|
}
|
|
|
|
|
|
2008-05-14 19:46:53 +02:00
|
|
|
static int git_branch_config(const char *var, const char *value, void *cb)
|
2006-12-12 07:41:52 +01:00
|
|
|
{
|
|
|
|
|
if (!strcmp(var, "color.branch")) {
|
2011-08-18 07:03:48 +02:00
|
|
|
branch_use_color = git_config_colorbool(var, value);
|
2006-12-12 07:41:52 +01:00
|
|
|
return 0;
|
|
|
|
|
}
|
Mechanical conversion to use prefixcmp()
This mechanically converts strncmp() to use prefixcmp(), but only when
the parameters match specific patterns, so that they can be verified
easily. Leftover from this will be fixed in a separate step, including
idiotic conversions like
if (!strncmp("foo", arg, 3))
=>
if (!(-prefixcmp(arg, "foo")))
This was done by using this script in px.perl
#!/usr/bin/perl -i.bak -p
if (/strncmp\(([^,]+), "([^\\"]*)", (\d+)\)/ && (length($2) == $3)) {
s|strncmp\(([^,]+), "([^\\"]*)", (\d+)\)|prefixcmp($1, "$2")|;
}
if (/strncmp\("([^\\"]*)", ([^,]+), (\d+)\)/ && (length($1) == $3)) {
s|strncmp\("([^\\"]*)", ([^,]+), (\d+)\)|(-prefixcmp($2, "$1"))|;
}
and running:
$ git grep -l strncmp -- '*.c' | xargs perl px.perl
Signed-off-by: Junio C Hamano <junkio@cox.net>
2007-02-20 10:53:29 +01:00
|
|
|
if (!prefixcmp(var, "color.branch.")) {
|
2006-12-12 07:41:52 +01:00
|
|
|
int slot = parse_branch_color_slot(var, 13);
|
ignore unknown color configuration
When parsing the config file, if there is a value that is
syntactically correct but unused, we generally ignore it.
This lets non-core porcelains store arbitrary information in
the config file, and it means that configuration files can
be shared between new and old versions of git (the old
versions might simply ignore certain configuration).
The one exception to this is color configuration; if we
encounter a color.{diff,branch,status}.$slot variable, we
die if it is not one of the recognized slots (presumably as
a safety valve for user misconfiguration). This behavior
has existed since 801235c (diff --color: use
$GIT_DIR/config, 2006-06-24), but hasn't yet caused a
problem. No porcelain has wanted to store extra colors, and
we once a color area (like color.diff) has been introduced,
we've never changed the set of color slots.
However, that changed recently with the addition of
color.diff.func. Now a user with color.diff.func in their
config can no longer freely switch between v1.6.6 and older
versions; the old versions will complain about the existence
of the variable.
This patch loosens the check to match the rest of
git-config; unknown color slots are simply ignored. This
doesn't fix this particular problem, as the older version
(without this patch) is the problem, but it at least
prevents it from happening again in the future.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2009-12-12 13:25:24 +01:00
|
|
|
if (slot < 0)
|
|
|
|
|
return 0;
|
2008-02-11 19:45:50 +01:00
|
|
|
if (!value)
|
|
|
|
|
return config_error_nonbool(var);
|
2006-12-12 07:41:52 +01:00
|
|
|
color_parse(value, var, branch_colors[slot]);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
2008-05-14 19:46:53 +02:00
|
|
|
return git_color_default_config(var, value, cb);
|
2006-12-12 07:41:52 +01:00
|
|
|
}
|
|
|
|
|
|
2007-06-07 22:45:00 +02:00
|
|
|
static const char *branch_get_color(enum color_branch ix)
|
2006-12-12 07:41:52 +01:00
|
|
|
{
|
color: delay auto-color decision until point of use
When we read a color value either from a config file or from
the command line, we use git_config_colorbool to convert it
from the tristate always/never/auto into a single yes/no
boolean value.
This has some timing implications with respect to starting
a pager.
If we start (or decide not to start) the pager before
checking the colorbool, everything is fine. Either isatty(1)
will give us the right information, or we will properly
check for pager_in_use().
However, if we decide to start a pager after we have checked
the colorbool, things are not so simple. If stdout is a tty,
then we will have already decided to use color. However, the
user may also have configured color.pager not to use color
with the pager. In this case, we need to actually turn off
color. Unfortunately, the pager code has no idea which color
variables were turned on (and there are many of them
throughout the code, and they may even have been manipulated
after the colorbool selection by something like "--color" on
the command line).
This bug can be seen any time a pager is started after
config and command line options are checked. This has
affected "git diff" since 89d07f7 (diff: don't run pager if
user asked for a diff style exit code, 2007-08-12). It has
also affect the log family since 1fda91b (Fix 'git log'
early pager startup error case, 2010-08-24).
This patch splits the notion of parsing a colorbool and
actually checking the configuration. The "use_color"
variables now have an additional possible value,
GIT_COLOR_AUTO. Users of the variable should use the new
"want_color()" wrapper, which will lazily determine and
cache the auto-color decision.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-08-18 07:04:23 +02:00
|
|
|
if (want_color(branch_use_color))
|
2006-12-12 07:41:52 +01:00
|
|
|
return branch_colors[ix];
|
|
|
|
|
return "";
|
|
|
|
|
}
|
|
|
|
|
|
2009-12-30 07:43:04 +01:00
|
|
|
static int branch_merged(int kind, const char *name,
|
|
|
|
|
struct commit *rev, struct commit *head_rev)
|
|
|
|
|
{
|
|
|
|
|
/*
|
|
|
|
|
* This checks whether the merge bases of branch and HEAD (or
|
|
|
|
|
* the other branch this branch builds upon) contains the
|
|
|
|
|
* branch, which means that the branch has already been merged
|
|
|
|
|
* safely to HEAD (or the other branch).
|
|
|
|
|
*/
|
|
|
|
|
struct commit *reference_rev = NULL;
|
|
|
|
|
const char *reference_name = NULL;
|
|
|
|
|
int merged;
|
|
|
|
|
|
|
|
|
|
if (kind == REF_LOCAL_BRANCH) {
|
|
|
|
|
struct branch *branch = branch_get(name);
|
|
|
|
|
unsigned char sha1[20];
|
|
|
|
|
|
|
|
|
|
if (branch &&
|
|
|
|
|
branch->merge &&
|
|
|
|
|
branch->merge[0] &&
|
|
|
|
|
branch->merge[0]->dst &&
|
|
|
|
|
(reference_name =
|
|
|
|
|
resolve_ref(branch->merge[0]->dst, sha1, 1, NULL)) != NULL)
|
|
|
|
|
reference_rev = lookup_commit_reference(sha1);
|
|
|
|
|
}
|
|
|
|
|
if (!reference_rev)
|
|
|
|
|
reference_rev = head_rev;
|
|
|
|
|
|
|
|
|
|
merged = in_merge_bases(rev, &reference_rev, 1);
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* After the safety valve is fully redefined to "check with
|
|
|
|
|
* upstream, if any, otherwise with HEAD", we should just
|
|
|
|
|
* return the result of the in_merge_bases() above without
|
|
|
|
|
* any of the following code, but during the transition period,
|
|
|
|
|
* a gentle reminder is in order.
|
|
|
|
|
*/
|
|
|
|
|
if ((head_rev != reference_rev) &&
|
|
|
|
|
in_merge_bases(rev, &head_rev, 1) != merged) {
|
|
|
|
|
if (merged)
|
2011-02-23 00:41:34 +01:00
|
|
|
warning(_("deleting branch '%s' that has been merged to\n"
|
2011-04-02 02:55:55 +02:00
|
|
|
" '%s', but not yet merged to HEAD."),
|
2009-12-30 07:43:04 +01:00
|
|
|
name, reference_name);
|
|
|
|
|
else
|
2011-02-23 00:41:34 +01:00
|
|
|
warning(_("not deleting branch '%s' that is not yet merged to\n"
|
|
|
|
|
" '%s', even though it is merged to HEAD."),
|
2009-12-30 07:43:04 +01:00
|
|
|
name, reference_name);
|
|
|
|
|
}
|
|
|
|
|
return merged;
|
|
|
|
|
}
|
|
|
|
|
|
2006-12-18 23:42:16 +01:00
|
|
|
static int delete_branches(int argc, const char **argv, int force, int kinds)
|
2006-10-23 23:27:45 +02:00
|
|
|
{
|
2009-12-30 07:43:04 +01:00
|
|
|
struct commit *rev, *head_rev = NULL;
|
2006-10-23 23:27:45 +02:00
|
|
|
unsigned char sha1[20];
|
2006-12-18 23:42:16 +01:00
|
|
|
char *name = NULL;
|
2006-12-18 08:58:16 +01:00
|
|
|
const char *fmt, *remote;
|
2006-10-23 23:27:45 +02:00
|
|
|
int i;
|
2006-12-18 23:42:16 +01:00
|
|
|
int ret = 0;
|
2009-02-14 08:08:05 +01:00
|
|
|
struct strbuf bname = STRBUF_INIT;
|
2006-10-23 23:27:45 +02:00
|
|
|
|
2006-12-18 08:58:16 +01:00
|
|
|
switch (kinds) {
|
|
|
|
|
case REF_REMOTE_BRANCH:
|
|
|
|
|
fmt = "refs/remotes/%s";
|
2011-02-23 00:41:35 +01:00
|
|
|
/* TRANSLATORS: This is "remote " in "remote branch '%s' not found" */
|
|
|
|
|
remote = _("remote ");
|
2006-12-18 08:58:16 +01:00
|
|
|
force = 1;
|
|
|
|
|
break;
|
|
|
|
|
case REF_LOCAL_BRANCH:
|
|
|
|
|
fmt = "refs/heads/%s";
|
|
|
|
|
remote = "";
|
|
|
|
|
break;
|
|
|
|
|
default:
|
2011-02-23 00:41:34 +01:00
|
|
|
die(_("cannot use -a with -d"));
|
2006-12-18 08:58:16 +01:00
|
|
|
}
|
2006-10-23 23:27:45 +02:00
|
|
|
|
2006-11-25 08:10:23 +01:00
|
|
|
if (!force) {
|
|
|
|
|
head_rev = lookup_commit_reference(head_sha1);
|
|
|
|
|
if (!head_rev)
|
2011-02-23 00:41:34 +01:00
|
|
|
die(_("Couldn't look up commit object for HEAD"));
|
2006-11-25 08:10:23 +01:00
|
|
|
}
|
2009-02-14 08:08:05 +01:00
|
|
|
for (i = 0; i < argc; i++, strbuf_release(&bname)) {
|
2009-03-21 21:17:30 +01:00
|
|
|
strbuf_branchname(&bname, argv[i]);
|
2009-02-14 08:08:05 +01:00
|
|
|
if (kinds == REF_LOCAL_BRANCH && !strcmp(head, bname.buf)) {
|
2011-02-23 00:41:34 +01:00
|
|
|
error(_("Cannot delete the branch '%s' "
|
|
|
|
|
"which you are currently on."), bname.buf);
|
2006-12-18 23:42:16 +01:00
|
|
|
ret = 1;
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
|
Avoid unnecessary "if-before-free" tests.
This change removes all obvious useless if-before-free tests.
E.g., it replaces code like this:
if (some_expression)
free (some_expression);
with the now-equivalent:
free (some_expression);
It is equivalent not just because POSIX has required free(NULL)
to work for a long time, but simply because it has worked for
so long that no reasonable porting target fails the test.
Here's some evidence from nearly 1.5 years ago:
http://www.winehq.org/pipermail/wine-patches/2006-October/031544.html
FYI, the change below was prepared by running the following:
git ls-files -z | xargs -0 \
perl -0x3b -pi -e \
's/\bif\s*\(\s*(\S+?)(?:\s*!=\s*NULL)?\s*\)\s+(free\s*\(\s*\1\s*\))/$2/s'
Note however, that it doesn't handle brace-enclosed blocks like
"if (x) { free (x); }". But that's ok, since there were none like
that in git sources.
Beware: if you do use the above snippet, note that it can
produce syntactically invalid C code. That happens when the
affected "if"-statement has a matching "else".
E.g., it would transform this
if (x)
free (x);
else
foo ();
into this:
free (x);
else
foo ();
There were none of those here, either.
If you're interested in automating detection of the useless
tests, you might like the useless-if-before-free script in gnulib:
[it *does* detect brace-enclosed free statements, and has a --name=S
option to make it detect free-like functions with different names]
http://git.sv.gnu.org/gitweb/?p=gnulib.git;a=blob;f=build-aux/useless-if-before-free
Addendum:
Remove one more (in imap-send.c), spotted by Jean-Luc Herren <jlh@gmx.ch>.
Signed-off-by: Jim Meyering <meyering@redhat.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-01-31 18:26:32 +01:00
|
|
|
free(name);
|
2006-10-23 23:27:45 +02:00
|
|
|
|
2009-02-14 08:08:05 +01:00
|
|
|
name = xstrdup(mkpath(fmt, bname.buf));
|
2006-12-18 23:42:16 +01:00
|
|
|
if (!resolve_ref(name, sha1, 1, NULL)) {
|
2011-02-23 00:41:34 +01:00
|
|
|
error(_("%sbranch '%s' not found."),
|
2009-02-14 08:08:05 +01:00
|
|
|
remote, bname.buf);
|
2006-12-18 23:42:16 +01:00
|
|
|
ret = 1;
|
|
|
|
|
continue;
|
|
|
|
|
}
|
2006-10-23 23:27:45 +02:00
|
|
|
|
|
|
|
|
rev = lookup_commit_reference(sha1);
|
2006-12-18 23:42:16 +01:00
|
|
|
if (!rev) {
|
2011-02-23 00:41:34 +01:00
|
|
|
error(_("Couldn't look up commit object for '%s'"), name);
|
2006-12-18 23:42:16 +01:00
|
|
|
ret = 1;
|
|
|
|
|
continue;
|
|
|
|
|
}
|
2006-10-23 23:27:45 +02:00
|
|
|
|
2009-12-30 07:43:04 +01:00
|
|
|
if (!force && !branch_merged(kinds, bname.buf, rev, head_rev)) {
|
2011-02-23 00:41:34 +01:00
|
|
|
error(_("The branch '%s' is not fully merged.\n"
|
2009-02-14 08:08:05 +01:00
|
|
|
"If you are sure you want to delete it, "
|
2011-02-23 00:41:34 +01:00
|
|
|
"run 'git branch -D %s'."), bname.buf, bname.buf);
|
2006-12-18 23:42:16 +01:00
|
|
|
ret = 1;
|
|
|
|
|
continue;
|
2006-10-23 23:27:45 +02:00
|
|
|
}
|
|
|
|
|
|
2008-10-26 03:33:56 +01:00
|
|
|
if (delete_ref(name, sha1, 0)) {
|
2011-02-23 00:41:34 +01:00
|
|
|
error(_("Error deleting %sbranch '%s'"), remote,
|
2009-02-14 08:08:05 +01:00
|
|
|
bname.buf);
|
2006-12-18 23:42:16 +01:00
|
|
|
ret = 1;
|
2007-06-09 14:40:35 +02:00
|
|
|
} else {
|
2008-11-17 21:48:35 +01:00
|
|
|
struct strbuf buf = STRBUF_INIT;
|
2011-02-23 00:41:36 +01:00
|
|
|
printf(_("Deleted %sbranch %s (was %s).\n"), remote,
|
2009-02-14 08:08:05 +01:00
|
|
|
bname.buf,
|
|
|
|
|
find_unique_abbrev(sha1, DEFAULT_ABBREV));
|
|
|
|
|
strbuf_addf(&buf, "branch.%s", bname.buf);
|
2008-11-17 21:48:35 +01:00
|
|
|
if (git_config_rename_section(buf.buf, NULL) < 0)
|
2011-02-23 00:41:34 +01:00
|
|
|
warning(_("Update of config-file failed"));
|
2008-11-17 21:48:35 +01:00
|
|
|
strbuf_release(&buf);
|
2007-06-09 14:40:35 +02:00
|
|
|
}
|
2006-10-23 23:27:45 +02:00
|
|
|
}
|
|
|
|
|
|
Avoid unnecessary "if-before-free" tests.
This change removes all obvious useless if-before-free tests.
E.g., it replaces code like this:
if (some_expression)
free (some_expression);
with the now-equivalent:
free (some_expression);
It is equivalent not just because POSIX has required free(NULL)
to work for a long time, but simply because it has worked for
so long that no reasonable porting target fails the test.
Here's some evidence from nearly 1.5 years ago:
http://www.winehq.org/pipermail/wine-patches/2006-October/031544.html
FYI, the change below was prepared by running the following:
git ls-files -z | xargs -0 \
perl -0x3b -pi -e \
's/\bif\s*\(\s*(\S+?)(?:\s*!=\s*NULL)?\s*\)\s+(free\s*\(\s*\1\s*\))/$2/s'
Note however, that it doesn't handle brace-enclosed blocks like
"if (x) { free (x); }". But that's ok, since there were none like
that in git sources.
Beware: if you do use the above snippet, note that it can
produce syntactically invalid C code. That happens when the
affected "if"-statement has a matching "else".
E.g., it would transform this
if (x)
free (x);
else
foo ();
into this:
free (x);
else
foo ();
There were none of those here, either.
If you're interested in automating detection of the useless
tests, you might like the useless-if-before-free script in gnulib:
[it *does* detect brace-enclosed free statements, and has a --name=S
option to make it detect free-like functions with different names]
http://git.sv.gnu.org/gitweb/?p=gnulib.git;a=blob;f=build-aux/useless-if-before-free
Addendum:
Remove one more (in imap-send.c), spotted by Jean-Luc Herren <jlh@gmx.ch>.
Signed-off-by: Jim Meyering <meyering@redhat.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-01-31 18:26:32 +01:00
|
|
|
free(name);
|
2006-12-18 23:42:16 +01:00
|
|
|
|
|
|
|
|
return(ret);
|
2006-10-23 23:27:45 +02:00
|
|
|
}
|
|
|
|
|
|
2006-11-21 20:31:24 +01:00
|
|
|
struct ref_item {
|
|
|
|
|
char *name;
|
2009-02-13 10:40:18 +01:00
|
|
|
char *dest;
|
|
|
|
|
unsigned int kind, len;
|
2008-07-24 00:13:41 +02:00
|
|
|
struct commit *commit;
|
2006-11-21 20:31:24 +01:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
struct ref_list {
|
2008-07-24 00:13:41 +02:00
|
|
|
struct rev_info revs;
|
2009-07-23 21:13:48 +02:00
|
|
|
int index, alloc, maxwidth, verbose, abbrev;
|
2006-11-21 20:31:24 +01:00
|
|
|
struct ref_item *list;
|
2007-11-07 23:58:09 +01:00
|
|
|
struct commit_list *with_commit;
|
2006-11-21 20:31:24 +01:00
|
|
|
int kinds;
|
|
|
|
|
};
|
|
|
|
|
|
2009-02-13 10:40:18 +01:00
|
|
|
static char *resolve_symref(const char *src, const char *prefix)
|
|
|
|
|
{
|
|
|
|
|
unsigned char sha1[20];
|
|
|
|
|
int flag;
|
|
|
|
|
const char *dst, *cp;
|
|
|
|
|
|
|
|
|
|
dst = resolve_ref(src, sha1, 0, &flag);
|
|
|
|
|
if (!(dst && (flag & REF_ISSYMREF)))
|
|
|
|
|
return NULL;
|
|
|
|
|
if (prefix && (cp = skip_prefix(dst, prefix)))
|
|
|
|
|
dst = cp;
|
|
|
|
|
return xstrdup(dst);
|
|
|
|
|
}
|
|
|
|
|
|
2010-06-04 11:50:10 +02:00
|
|
|
struct append_ref_cb {
|
|
|
|
|
struct ref_list *ref_list;
|
2011-08-28 16:54:32 +02:00
|
|
|
const char **pattern;
|
2010-06-04 11:50:10 +02:00
|
|
|
int ret;
|
|
|
|
|
};
|
|
|
|
|
|
2011-08-28 16:54:32 +02:00
|
|
|
static int match_patterns(const char **pattern, const char *refname)
|
|
|
|
|
{
|
|
|
|
|
if (!*pattern)
|
|
|
|
|
return 1; /* no pattern always matches */
|
|
|
|
|
while (*pattern) {
|
|
|
|
|
if (!fnmatch(*pattern, refname, 0))
|
|
|
|
|
return 1;
|
|
|
|
|
pattern++;
|
|
|
|
|
}
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2006-11-21 20:31:24 +01:00
|
|
|
static int append_ref(const char *refname, const unsigned char *sha1, int flags, void *cb_data)
|
2006-10-23 23:27:45 +02:00
|
|
|
{
|
2010-06-04 11:50:10 +02:00
|
|
|
struct append_ref_cb *cb = (struct append_ref_cb *)(cb_data);
|
|
|
|
|
struct ref_list *ref_list = cb->ref_list;
|
2006-11-21 20:31:24 +01:00
|
|
|
struct ref_item *newitem;
|
2008-07-24 00:13:41 +02:00
|
|
|
struct commit *commit;
|
2009-02-13 10:40:18 +01:00
|
|
|
int kind, i;
|
|
|
|
|
const char *prefix, *orig_refname = refname;
|
|
|
|
|
|
|
|
|
|
static struct {
|
|
|
|
|
int kind;
|
|
|
|
|
const char *prefix;
|
|
|
|
|
int pfxlen;
|
|
|
|
|
} ref_kind[] = {
|
|
|
|
|
{ REF_LOCAL_BRANCH, "refs/heads/", 11 },
|
|
|
|
|
{ REF_REMOTE_BRANCH, "refs/remotes/", 13 },
|
|
|
|
|
};
|
2006-11-21 20:31:24 +01:00
|
|
|
|
|
|
|
|
/* Detect kind */
|
2009-02-13 10:40:18 +01:00
|
|
|
for (i = 0; i < ARRAY_SIZE(ref_kind); i++) {
|
|
|
|
|
prefix = ref_kind[i].prefix;
|
|
|
|
|
if (strncmp(refname, prefix, ref_kind[i].pfxlen))
|
|
|
|
|
continue;
|
|
|
|
|
kind = ref_kind[i].kind;
|
|
|
|
|
refname += ref_kind[i].pfxlen;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
if (ARRAY_SIZE(ref_kind) <= i)
|
2008-07-23 23:52:47 +02:00
|
|
|
return 0;
|
2006-11-21 20:31:24 +01:00
|
|
|
|
|
|
|
|
/* Don't add types the caller doesn't want */
|
|
|
|
|
if ((kind & ref_list->kinds) == 0)
|
|
|
|
|
return 0;
|
|
|
|
|
|
2011-08-28 16:54:32 +02:00
|
|
|
if (!match_patterns(cb->pattern, refname))
|
|
|
|
|
return 0;
|
|
|
|
|
|
2009-07-23 21:05:34 +02:00
|
|
|
commit = NULL;
|
|
|
|
|
if (ref_list->verbose || ref_list->with_commit || merge_filter != NO_FILTER) {
|
|
|
|
|
commit = lookup_commit_reference_gently(sha1, 1);
|
2010-06-04 11:50:10 +02:00
|
|
|
if (!commit) {
|
2011-02-23 00:41:34 +01:00
|
|
|
cb->ret = error(_("branch '%s' does not point at a commit"), refname);
|
2010-06-04 11:50:11 +02:00
|
|
|
return 0;
|
2010-06-04 11:50:10 +02:00
|
|
|
}
|
2008-07-24 00:13:41 +02:00
|
|
|
|
2009-07-23 21:05:34 +02:00
|
|
|
/* Filter with with_commit if specified */
|
|
|
|
|
if (!is_descendant_of(commit, ref_list->with_commit))
|
|
|
|
|
return 0;
|
2007-11-07 23:58:09 +01:00
|
|
|
|
2009-07-23 21:05:34 +02:00
|
|
|
if (merge_filter != NO_FILTER)
|
|
|
|
|
add_pending_object(&ref_list->revs,
|
|
|
|
|
(struct object *)commit, refname);
|
|
|
|
|
}
|
2008-04-17 22:24:50 +02:00
|
|
|
|
2010-12-14 02:59:55 +01:00
|
|
|
ALLOC_GROW(ref_list->list, ref_list->index + 1, ref_list->alloc);
|
2006-10-23 23:27:45 +02:00
|
|
|
|
2006-11-21 20:31:24 +01:00
|
|
|
/* Record the new item */
|
|
|
|
|
newitem = &(ref_list->list[ref_list->index++]);
|
|
|
|
|
newitem->name = xstrdup(refname);
|
|
|
|
|
newitem->kind = kind;
|
2008-07-24 00:13:41 +02:00
|
|
|
newitem->commit = commit;
|
2009-02-13 10:40:18 +01:00
|
|
|
newitem->len = strlen(refname);
|
|
|
|
|
newitem->dest = resolve_symref(orig_refname, prefix);
|
|
|
|
|
/* adjust for "remotes/" */
|
|
|
|
|
if (newitem->kind == REF_REMOTE_BRANCH &&
|
|
|
|
|
ref_list->kinds != REF_REMOTE_BRANCH)
|
|
|
|
|
newitem->len += 8;
|
|
|
|
|
if (newitem->len > ref_list->maxwidth)
|
|
|
|
|
ref_list->maxwidth = newitem->len;
|
2006-10-23 23:27:45 +02:00
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2006-11-21 20:31:24 +01:00
|
|
|
static void free_ref_list(struct ref_list *ref_list)
|
|
|
|
|
{
|
|
|
|
|
int i;
|
|
|
|
|
|
2009-02-13 10:40:18 +01:00
|
|
|
for (i = 0; i < ref_list->index; i++) {
|
2006-11-21 20:31:24 +01:00
|
|
|
free(ref_list->list[i].name);
|
2009-02-13 10:40:18 +01:00
|
|
|
free(ref_list->list[i].dest);
|
|
|
|
|
}
|
2006-11-21 20:31:24 +01:00
|
|
|
free(ref_list->list);
|
|
|
|
|
}
|
|
|
|
|
|
2006-10-23 23:27:45 +02:00
|
|
|
static int ref_cmp(const void *r1, const void *r2)
|
|
|
|
|
{
|
2006-11-21 20:31:24 +01:00
|
|
|
struct ref_item *c1 = (struct ref_item *)(r1);
|
|
|
|
|
struct ref_item *c2 = (struct ref_item *)(r2);
|
|
|
|
|
|
|
|
|
|
if (c1->kind != c2->kind)
|
|
|
|
|
return c1->kind - c2->kind;
|
|
|
|
|
return strcmp(c1->name, c2->name);
|
2006-10-23 23:27:45 +02:00
|
|
|
}
|
|
|
|
|
|
2009-04-07 09:16:56 +02:00
|
|
|
static void fill_tracking_info(struct strbuf *stat, const char *branch_name,
|
|
|
|
|
int show_upstream_ref)
|
2008-07-02 09:52:41 +02:00
|
|
|
{
|
|
|
|
|
int ours, theirs;
|
|
|
|
|
struct branch *branch = branch_get(branch_name);
|
|
|
|
|
|
2009-04-07 09:16:56 +02:00
|
|
|
if (!stat_tracking_info(branch, &ours, &theirs)) {
|
|
|
|
|
if (branch && branch->merge && branch->merge[0]->dst &&
|
|
|
|
|
show_upstream_ref)
|
|
|
|
|
strbuf_addf(stat, "[%s] ",
|
2009-04-13 12:25:46 +02:00
|
|
|
shorten_unambiguous_ref(branch->merge[0]->dst, 0));
|
2008-07-02 09:52:41 +02:00
|
|
|
return;
|
2009-04-07 09:16:56 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
strbuf_addch(stat, '[');
|
|
|
|
|
if (show_upstream_ref)
|
|
|
|
|
strbuf_addf(stat, "%s: ",
|
2009-04-13 12:25:46 +02:00
|
|
|
shorten_unambiguous_ref(branch->merge[0]->dst, 0));
|
2008-07-02 09:52:41 +02:00
|
|
|
if (!ours)
|
2011-02-23 00:41:37 +01:00
|
|
|
strbuf_addf(stat, _("behind %d] "), theirs);
|
2008-07-02 09:52:41 +02:00
|
|
|
else if (!theirs)
|
2011-02-23 00:41:37 +01:00
|
|
|
strbuf_addf(stat, _("ahead %d] "), ours);
|
2008-07-02 09:52:41 +02:00
|
|
|
else
|
2011-02-23 00:41:37 +01:00
|
|
|
strbuf_addf(stat, _("ahead %d, behind %d] "), ours, theirs);
|
2008-07-02 09:52:41 +02:00
|
|
|
}
|
|
|
|
|
|
2008-07-26 12:27:24 +02:00
|
|
|
static int matches_merge_filter(struct commit *commit)
|
|
|
|
|
{
|
|
|
|
|
int is_merged;
|
|
|
|
|
|
|
|
|
|
if (merge_filter == NO_FILTER)
|
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
|
|
is_merged = !!(commit->object.flags & UNINTERESTING);
|
|
|
|
|
return (is_merged == (merge_filter == SHOW_MERGED));
|
|
|
|
|
}
|
|
|
|
|
|
2011-03-16 08:10:14 +01:00
|
|
|
static void add_verbose_info(struct strbuf *out, struct ref_item *item,
|
|
|
|
|
int verbose, int abbrev)
|
|
|
|
|
{
|
|
|
|
|
struct strbuf subject = STRBUF_INIT, stat = STRBUF_INIT;
|
|
|
|
|
const char *sub = " **** invalid ref ****";
|
|
|
|
|
struct commit *commit = item->commit;
|
|
|
|
|
|
|
|
|
|
if (commit && !parse_commit(commit)) {
|
2011-05-31 21:19:11 +02:00
|
|
|
pp_commit_easy(CMIT_FMT_ONELINE, commit, &subject);
|
2011-03-16 08:10:14 +01:00
|
|
|
sub = subject.buf;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (item->kind == REF_LOCAL_BRANCH)
|
|
|
|
|
fill_tracking_info(&stat, item->name, verbose > 1);
|
|
|
|
|
|
|
|
|
|
strbuf_addf(out, " %s %s%s",
|
|
|
|
|
find_unique_abbrev(item->commit->object.sha1, abbrev),
|
|
|
|
|
stat.buf, sub);
|
|
|
|
|
strbuf_release(&stat);
|
|
|
|
|
strbuf_release(&subject);
|
|
|
|
|
}
|
|
|
|
|
|
2007-01-03 21:10:09 +01:00
|
|
|
static void print_ref_item(struct ref_item *item, int maxwidth, int verbose,
|
2009-02-13 10:40:18 +01:00
|
|
|
int abbrev, int current, char *prefix)
|
2006-11-24 14:45:10 +01:00
|
|
|
{
|
2007-01-03 21:10:09 +01:00
|
|
|
char c;
|
|
|
|
|
int color;
|
2008-07-24 00:13:41 +02:00
|
|
|
struct commit *commit = item->commit;
|
2009-02-13 10:40:18 +01:00
|
|
|
struct strbuf out = STRBUF_INIT, name = STRBUF_INIT;
|
2008-07-24 00:13:41 +02:00
|
|
|
|
2008-07-26 12:27:24 +02:00
|
|
|
if (!matches_merge_filter(commit))
|
|
|
|
|
return;
|
2006-11-24 14:45:10 +01:00
|
|
|
|
2007-01-03 21:10:09 +01:00
|
|
|
switch (item->kind) {
|
|
|
|
|
case REF_LOCAL_BRANCH:
|
2009-02-13 22:53:41 +01:00
|
|
|
color = BRANCH_COLOR_LOCAL;
|
2007-01-03 21:10:09 +01:00
|
|
|
break;
|
|
|
|
|
case REF_REMOTE_BRANCH:
|
2009-02-13 22:53:41 +01:00
|
|
|
color = BRANCH_COLOR_REMOTE;
|
2007-01-03 21:10:09 +01:00
|
|
|
break;
|
|
|
|
|
default:
|
2009-02-13 22:53:41 +01:00
|
|
|
color = BRANCH_COLOR_PLAIN;
|
2007-01-03 21:10:09 +01:00
|
|
|
break;
|
|
|
|
|
}
|
2006-11-24 14:45:10 +01:00
|
|
|
|
2007-01-03 21:10:09 +01:00
|
|
|
c = ' ';
|
|
|
|
|
if (current) {
|
|
|
|
|
c = '*';
|
2009-02-13 22:53:41 +01:00
|
|
|
color = BRANCH_COLOR_CURRENT;
|
2007-01-03 21:10:09 +01:00
|
|
|
}
|
2006-11-24 14:45:10 +01:00
|
|
|
|
2009-02-13 10:40:18 +01:00
|
|
|
strbuf_addf(&name, "%s%s", prefix, item->name);
|
|
|
|
|
if (verbose)
|
|
|
|
|
strbuf_addf(&out, "%c %s%-*s%s", c, branch_get_color(color),
|
|
|
|
|
maxwidth, name.buf,
|
2009-03-06 00:41:35 +01:00
|
|
|
branch_get_color(BRANCH_COLOR_RESET));
|
2009-02-13 10:40:18 +01:00
|
|
|
else
|
|
|
|
|
strbuf_addf(&out, "%c %s%s%s", c, branch_get_color(color),
|
2009-03-06 00:41:35 +01:00
|
|
|
name.buf, branch_get_color(BRANCH_COLOR_RESET));
|
2009-02-13 10:40:18 +01:00
|
|
|
|
|
|
|
|
if (item->dest)
|
|
|
|
|
strbuf_addf(&out, " -> %s", item->dest);
|
2011-03-16 08:10:14 +01:00
|
|
|
else if (verbose)
|
|
|
|
|
/* " f7c0c00 [ahead 58, behind 197] vcs-svn: drop obj_pool.h" */
|
|
|
|
|
add_verbose_info(&out, item, verbose, abbrev);
|
2009-02-13 10:40:18 +01:00
|
|
|
printf("%s\n", out.buf);
|
|
|
|
|
strbuf_release(&name);
|
|
|
|
|
strbuf_release(&out);
|
2006-11-24 14:45:10 +01:00
|
|
|
}
|
|
|
|
|
|
2008-07-26 12:27:25 +02:00
|
|
|
static int calc_maxwidth(struct ref_list *refs)
|
|
|
|
|
{
|
2009-02-13 10:40:18 +01:00
|
|
|
int i, w = 0;
|
2008-07-26 12:27:25 +02:00
|
|
|
for (i = 0; i < refs->index; i++) {
|
|
|
|
|
if (!matches_merge_filter(refs->list[i].commit))
|
|
|
|
|
continue;
|
2009-02-13 10:40:18 +01:00
|
|
|
if (refs->list[i].len > w)
|
|
|
|
|
w = refs->list[i].len;
|
2008-07-26 12:27:25 +02:00
|
|
|
}
|
|
|
|
|
return w;
|
|
|
|
|
}
|
|
|
|
|
|
2009-07-23 21:13:48 +02:00
|
|
|
|
|
|
|
|
static void show_detached(struct ref_list *ref_list)
|
|
|
|
|
{
|
|
|
|
|
struct commit *head_commit = lookup_commit_reference_gently(head_sha1, 1);
|
|
|
|
|
|
|
|
|
|
if (head_commit && is_descendant_of(head_commit, ref_list->with_commit)) {
|
|
|
|
|
struct ref_item item;
|
2011-02-23 00:41:38 +01:00
|
|
|
item.name = xstrdup(_("(no branch)"));
|
2009-07-23 21:13:48 +02:00
|
|
|
item.len = strlen(item.name);
|
|
|
|
|
item.kind = REF_LOCAL_BRANCH;
|
|
|
|
|
item.dest = NULL;
|
|
|
|
|
item.commit = head_commit;
|
|
|
|
|
if (item.len > ref_list->maxwidth)
|
|
|
|
|
ref_list->maxwidth = item.len;
|
|
|
|
|
print_ref_item(&item, ref_list->maxwidth, ref_list->verbose, ref_list->abbrev, 1, "");
|
|
|
|
|
free(item.name);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2011-08-28 16:54:32 +02:00
|
|
|
static int print_ref_list(int kinds, int detached, int verbose, int abbrev, struct commit_list *with_commit, const char **pattern)
|
2006-10-23 23:27:45 +02:00
|
|
|
{
|
|
|
|
|
int i;
|
2010-06-04 11:50:10 +02:00
|
|
|
struct append_ref_cb cb;
|
2006-11-21 20:31:24 +01:00
|
|
|
struct ref_list ref_list;
|
2006-10-23 23:27:45 +02:00
|
|
|
|
2006-11-21 20:31:24 +01:00
|
|
|
memset(&ref_list, 0, sizeof(ref_list));
|
|
|
|
|
ref_list.kinds = kinds;
|
2009-07-23 21:05:34 +02:00
|
|
|
ref_list.verbose = verbose;
|
2009-07-23 21:13:48 +02:00
|
|
|
ref_list.abbrev = abbrev;
|
2007-11-07 23:58:09 +01:00
|
|
|
ref_list.with_commit = with_commit;
|
2008-07-24 00:13:41 +02:00
|
|
|
if (merge_filter != NO_FILTER)
|
|
|
|
|
init_revisions(&ref_list.revs, NULL);
|
2010-06-04 11:50:10 +02:00
|
|
|
cb.ref_list = &ref_list;
|
2011-08-28 16:54:32 +02:00
|
|
|
cb.pattern = pattern;
|
2010-06-04 11:50:10 +02:00
|
|
|
cb.ret = 0;
|
|
|
|
|
for_each_rawref(append_ref, &cb);
|
2008-07-24 00:13:41 +02:00
|
|
|
if (merge_filter != NO_FILTER) {
|
|
|
|
|
struct commit *filter;
|
|
|
|
|
filter = lookup_commit_reference_gently(merge_filter_ref, 0);
|
|
|
|
|
filter->object.flags |= UNINTERESTING;
|
|
|
|
|
add_pending_object(&ref_list.revs,
|
|
|
|
|
(struct object *) filter, "");
|
|
|
|
|
ref_list.revs.limited = 1;
|
|
|
|
|
prepare_revision_walk(&ref_list.revs);
|
2008-07-26 12:27:25 +02:00
|
|
|
if (verbose)
|
|
|
|
|
ref_list.maxwidth = calc_maxwidth(&ref_list);
|
2008-07-24 00:13:41 +02:00
|
|
|
}
|
2006-10-23 23:27:45 +02:00
|
|
|
|
2006-11-21 20:31:24 +01:00
|
|
|
qsort(ref_list.list, ref_list.index, sizeof(struct ref_item), ref_cmp);
|
2006-10-23 23:27:45 +02:00
|
|
|
|
2007-01-03 21:10:10 +01:00
|
|
|
detached = (detached && (kinds & REF_LOCAL_BRANCH));
|
2011-08-28 16:54:32 +02:00
|
|
|
if (detached && match_patterns(pattern, "HEAD"))
|
2009-07-23 21:13:48 +02:00
|
|
|
show_detached(&ref_list);
|
2007-01-03 21:10:10 +01:00
|
|
|
|
2006-11-21 20:31:24 +01:00
|
|
|
for (i = 0; i < ref_list.index; i++) {
|
2007-01-03 21:10:10 +01:00
|
|
|
int current = !detached &&
|
|
|
|
|
(ref_list.list[i].kind == REF_LOCAL_BRANCH) &&
|
2007-01-03 21:10:09 +01:00
|
|
|
!strcmp(ref_list.list[i].name, head);
|
2009-02-13 10:40:18 +01:00
|
|
|
char *prefix = (kinds != REF_REMOTE_BRANCH &&
|
|
|
|
|
ref_list.list[i].kind == REF_REMOTE_BRANCH)
|
|
|
|
|
? "remotes/" : "";
|
2007-01-03 21:10:09 +01:00
|
|
|
print_ref_item(&ref_list.list[i], ref_list.maxwidth, verbose,
|
2009-02-13 10:40:18 +01:00
|
|
|
abbrev, current, prefix);
|
2006-10-23 23:27:45 +02:00
|
|
|
}
|
2006-11-21 20:31:24 +01:00
|
|
|
|
|
|
|
|
free_ref_list(&ref_list);
|
2010-06-04 11:50:10 +02:00
|
|
|
|
2010-06-04 11:50:11 +02:00
|
|
|
if (cb.ret)
|
2011-02-23 00:41:34 +01:00
|
|
|
error(_("some refs could not be read"));
|
2010-06-04 11:50:11 +02:00
|
|
|
|
2010-06-04 11:50:10 +02:00
|
|
|
return cb.ret;
|
2006-10-23 23:27:45 +02:00
|
|
|
}
|
|
|
|
|
|
2006-11-28 15:47:40 +01:00
|
|
|
static void rename_branch(const char *oldname, const char *newname, int force)
|
|
|
|
|
{
|
2008-11-17 21:48:37 +01:00
|
|
|
struct strbuf oldref = STRBUF_INIT, newref = STRBUF_INIT, logmsg = STRBUF_INIT;
|
2006-11-28 15:47:40 +01:00
|
|
|
unsigned char sha1[20];
|
2008-11-17 21:48:37 +01:00
|
|
|
struct strbuf oldsection = STRBUF_INIT, newsection = STRBUF_INIT;
|
check_ref_format(): tighten refname rules
This changes the rules for refnames to forbid:
(1) a refname that contains "@{" in it.
Some people and foreign SCM converter may have named their branches
as frotz@24 and we still want to keep supporting it.
However, "git branch frotz@{24}" is a disaster. It cannot even
checked out because "git checkout frotz@{24}" will interpret it as
"detach the HEAD at twenty-fourth reflog entry of the frotz branch".
(2) a refname that ends with a dot.
We already reject a path component that begins with a dot, primarily
to avoid ambiguous range interpretation. If we allowed ".B" as a
valid ref, it is unclear if "A...B" means "in dot-B but not in A" or
"either in A or B but not in both".
But for this to be complete, we need also to forbid "A." to avoid "in
B but not in A-dot". This was not a problem in the original range
notation, but we should have added this restriction when three-dot
notation was introduced.
Unlike "no dot at the beginning of any path component" rule, this
rule does not have to be "no dot at the end of any path component",
because you cannot abbreviate the tail end away, similar to you can
say "dot-B" to mean "refs/heads/dot-B".
For these reasons, it is not likely people created branches with these
names on purpose, but we have allowed such names to be used for quite some
time, and it is possible that people created such branches by mistake or
by accident.
To help people with branches with such unfortunate names to recover,
we still allow "branch -d 'bad.'" to delete such branches, and also allow
"branch -m bad. good" to rename them.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2009-03-21 21:27:31 +01:00
|
|
|
int recovery = 0;
|
2006-11-28 15:47:40 +01:00
|
|
|
|
2007-01-02 08:31:08 +01:00
|
|
|
if (!oldname)
|
2011-02-23 00:41:34 +01:00
|
|
|
die(_("cannot rename the current branch while not on any."));
|
2007-01-02 08:31:08 +01:00
|
|
|
|
check_ref_format(): tighten refname rules
This changes the rules for refnames to forbid:
(1) a refname that contains "@{" in it.
Some people and foreign SCM converter may have named their branches
as frotz@24 and we still want to keep supporting it.
However, "git branch frotz@{24}" is a disaster. It cannot even
checked out because "git checkout frotz@{24}" will interpret it as
"detach the HEAD at twenty-fourth reflog entry of the frotz branch".
(2) a refname that ends with a dot.
We already reject a path component that begins with a dot, primarily
to avoid ambiguous range interpretation. If we allowed ".B" as a
valid ref, it is unclear if "A...B" means "in dot-B but not in A" or
"either in A or B but not in both".
But for this to be complete, we need also to forbid "A." to avoid "in
B but not in A-dot". This was not a problem in the original range
notation, but we should have added this restriction when three-dot
notation was introduced.
Unlike "no dot at the beginning of any path component" rule, this
rule does not have to be "no dot at the end of any path component",
because you cannot abbreviate the tail end away, similar to you can
say "dot-B" to mean "refs/heads/dot-B".
For these reasons, it is not likely people created branches with these
names on purpose, but we have allowed such names to be used for quite some
time, and it is possible that people created such branches by mistake or
by accident.
To help people with branches with such unfortunate names to recover,
we still allow "branch -d 'bad.'" to delete such branches, and also allow
"branch -m bad. good" to rename them.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2009-03-21 21:27:31 +01:00
|
|
|
if (strbuf_check_branch_ref(&oldref, oldname)) {
|
|
|
|
|
/*
|
|
|
|
|
* Bad name --- this could be an attempt to rename a
|
|
|
|
|
* ref that we used to allow to be created by accident.
|
|
|
|
|
*/
|
|
|
|
|
if (resolve_ref(oldref.buf, sha1, 1, NULL))
|
|
|
|
|
recovery = 1;
|
|
|
|
|
else
|
2011-02-23 00:41:34 +01:00
|
|
|
die(_("Invalid branch name: '%s'"), oldname);
|
check_ref_format(): tighten refname rules
This changes the rules for refnames to forbid:
(1) a refname that contains "@{" in it.
Some people and foreign SCM converter may have named their branches
as frotz@24 and we still want to keep supporting it.
However, "git branch frotz@{24}" is a disaster. It cannot even
checked out because "git checkout frotz@{24}" will interpret it as
"detach the HEAD at twenty-fourth reflog entry of the frotz branch".
(2) a refname that ends with a dot.
We already reject a path component that begins with a dot, primarily
to avoid ambiguous range interpretation. If we allowed ".B" as a
valid ref, it is unclear if "A...B" means "in dot-B but not in A" or
"either in A or B but not in both".
But for this to be complete, we need also to forbid "A." to avoid "in
B but not in A-dot". This was not a problem in the original range
notation, but we should have added this restriction when three-dot
notation was introduced.
Unlike "no dot at the beginning of any path component" rule, this
rule does not have to be "no dot at the end of any path component",
because you cannot abbreviate the tail end away, similar to you can
say "dot-B" to mean "refs/heads/dot-B".
For these reasons, it is not likely people created branches with these
names on purpose, but we have allowed such names to be used for quite some
time, and it is possible that people created such branches by mistake or
by accident.
To help people with branches with such unfortunate names to recover,
we still allow "branch -d 'bad.'" to delete such branches, and also allow
"branch -m bad. good" to rename them.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2009-03-21 21:27:31 +01:00
|
|
|
}
|
2006-11-28 15:47:40 +01:00
|
|
|
|
2011-09-17 01:28:38 +02:00
|
|
|
validate_new_branchname(newname, &newref, force, 0);
|
2006-11-28 15:47:40 +01:00
|
|
|
|
2008-11-17 21:48:37 +01:00
|
|
|
strbuf_addf(&logmsg, "Branch: renamed %s to %s",
|
|
|
|
|
oldref.buf, newref.buf);
|
2006-11-30 03:16:56 +01:00
|
|
|
|
2008-11-17 21:48:37 +01:00
|
|
|
if (rename_ref(oldref.buf, newref.buf, logmsg.buf))
|
2011-02-23 00:41:34 +01:00
|
|
|
die(_("Branch rename failed"));
|
2008-11-17 21:48:37 +01:00
|
|
|
strbuf_release(&logmsg);
|
2006-11-28 15:47:40 +01:00
|
|
|
|
check_ref_format(): tighten refname rules
This changes the rules for refnames to forbid:
(1) a refname that contains "@{" in it.
Some people and foreign SCM converter may have named their branches
as frotz@24 and we still want to keep supporting it.
However, "git branch frotz@{24}" is a disaster. It cannot even
checked out because "git checkout frotz@{24}" will interpret it as
"detach the HEAD at twenty-fourth reflog entry of the frotz branch".
(2) a refname that ends with a dot.
We already reject a path component that begins with a dot, primarily
to avoid ambiguous range interpretation. If we allowed ".B" as a
valid ref, it is unclear if "A...B" means "in dot-B but not in A" or
"either in A or B but not in both".
But for this to be complete, we need also to forbid "A." to avoid "in
B but not in A-dot". This was not a problem in the original range
notation, but we should have added this restriction when three-dot
notation was introduced.
Unlike "no dot at the beginning of any path component" rule, this
rule does not have to be "no dot at the end of any path component",
because you cannot abbreviate the tail end away, similar to you can
say "dot-B" to mean "refs/heads/dot-B".
For these reasons, it is not likely people created branches with these
names on purpose, but we have allowed such names to be used for quite some
time, and it is possible that people created such branches by mistake or
by accident.
To help people with branches with such unfortunate names to recover,
we still allow "branch -d 'bad.'" to delete such branches, and also allow
"branch -m bad. good" to rename them.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2009-03-21 21:27:31 +01:00
|
|
|
if (recovery)
|
2011-02-23 00:41:34 +01:00
|
|
|
warning(_("Renamed a misnamed branch '%s' away"), oldref.buf + 11);
|
check_ref_format(): tighten refname rules
This changes the rules for refnames to forbid:
(1) a refname that contains "@{" in it.
Some people and foreign SCM converter may have named their branches
as frotz@24 and we still want to keep supporting it.
However, "git branch frotz@{24}" is a disaster. It cannot even
checked out because "git checkout frotz@{24}" will interpret it as
"detach the HEAD at twenty-fourth reflog entry of the frotz branch".
(2) a refname that ends with a dot.
We already reject a path component that begins with a dot, primarily
to avoid ambiguous range interpretation. If we allowed ".B" as a
valid ref, it is unclear if "A...B" means "in dot-B but not in A" or
"either in A or B but not in both".
But for this to be complete, we need also to forbid "A." to avoid "in
B but not in A-dot". This was not a problem in the original range
notation, but we should have added this restriction when three-dot
notation was introduced.
Unlike "no dot at the beginning of any path component" rule, this
rule does not have to be "no dot at the end of any path component",
because you cannot abbreviate the tail end away, similar to you can
say "dot-B" to mean "refs/heads/dot-B".
For these reasons, it is not likely people created branches with these
names on purpose, but we have allowed such names to be used for quite some
time, and it is possible that people created such branches by mistake or
by accident.
To help people with branches with such unfortunate names to recover,
we still allow "branch -d 'bad.'" to delete such branches, and also allow
"branch -m bad. good" to rename them.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2009-03-21 21:27:31 +01:00
|
|
|
|
2007-01-26 23:26:10 +01:00
|
|
|
/* no need to pass logmsg here as HEAD didn't really move */
|
2008-11-17 21:48:37 +01:00
|
|
|
if (!strcmp(oldname, head) && create_symref("HEAD", newref.buf, NULL))
|
2011-02-23 00:41:34 +01:00
|
|
|
die(_("Branch renamed to %s, but HEAD is not updated!"), newname);
|
2007-04-06 14:13:00 +02:00
|
|
|
|
2008-11-17 21:48:37 +01:00
|
|
|
strbuf_addf(&oldsection, "branch.%s", oldref.buf + 11);
|
|
|
|
|
strbuf_release(&oldref);
|
|
|
|
|
strbuf_addf(&newsection, "branch.%s", newref.buf + 11);
|
|
|
|
|
strbuf_release(&newref);
|
|
|
|
|
if (git_config_rename_section(oldsection.buf, newsection.buf) < 0)
|
2011-02-23 00:41:34 +01:00
|
|
|
die(_("Branch is renamed, but update of config-file failed"));
|
2008-11-17 21:48:37 +01:00
|
|
|
strbuf_release(&oldsection);
|
|
|
|
|
strbuf_release(&newsection);
|
2006-11-28 15:47:40 +01:00
|
|
|
}
|
|
|
|
|
|
2008-07-09 02:55:47 +02:00
|
|
|
static int opt_parse_merge_filter(const struct option *opt, const char *arg, int unset)
|
|
|
|
|
{
|
|
|
|
|
merge_filter = ((opt->long_name[0] == 'n')
|
|
|
|
|
? SHOW_NOT_MERGED
|
|
|
|
|
: SHOW_MERGED);
|
|
|
|
|
if (unset)
|
|
|
|
|
merge_filter = SHOW_NOT_MERGED; /* b/c for --no-merged */
|
|
|
|
|
if (!arg)
|
|
|
|
|
arg = "HEAD";
|
|
|
|
|
if (get_sha1(arg, merge_filter_ref))
|
2011-02-23 00:41:34 +01:00
|
|
|
die(_("malformed object name %s"), arg);
|
2008-07-09 02:55:47 +02:00
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2006-10-23 23:27:45 +02:00
|
|
|
int cmd_branch(int argc, const char **argv, const char *prefix)
|
|
|
|
|
{
|
2011-08-28 16:54:31 +02:00
|
|
|
int delete = 0, rename = 0, force_create = 0, list = 0;
|
2011-07-01 08:06:08 +02:00
|
|
|
int verbose = 0, abbrev = -1, detached = 0;
|
2008-02-19 17:24:37 +01:00
|
|
|
int reflog = 0;
|
|
|
|
|
enum branch_track track;
|
2007-11-07 11:20:28 +01:00
|
|
|
int kinds = REF_LOCAL_BRANCH;
|
2007-11-07 23:58:09 +01:00
|
|
|
struct commit_list *with_commit = NULL;
|
2007-10-07 18:26:21 +02:00
|
|
|
|
|
|
|
|
struct option options[] = {
|
|
|
|
|
OPT_GROUP("Generic options"),
|
2010-11-08 19:03:58 +01:00
|
|
|
OPT__VERBOSE(&verbose,
|
|
|
|
|
"show hash and subject, give twice for upstream branch"),
|
2009-04-28 17:21:20 +02:00
|
|
|
OPT_SET_INT('t', "track", &track, "set up tracking mode (see git-pull(1))",
|
2008-02-19 17:24:37 +01:00
|
|
|
BRANCH_TRACK_EXPLICIT),
|
2010-01-18 21:44:11 +01:00
|
|
|
OPT_SET_INT( 0, "set-upstream", &track, "change upstream info",
|
|
|
|
|
BRANCH_TRACK_OVERRIDE),
|
Add an optional argument for --color options
Make git-branch, git-show-branch, git-grep, and all the diff-based
programs accept an optional argument <when> for --color. The argument
is a colorbool: "always", "never", or "auto". If no argument is given,
"always" is used; --no-color is an alias for --color=never. This makes
the command-line interface consistent with other GNU tools, such as `ls'
and `grep', and with the git-config color options. Note that, without
an argument, --color and --no-color work exactly as before.
To implement this, two internal changes were made:
1. Allow the first argument of git_config_colorbool() to be NULL,
in which case it returns -1 if the argument isn't "always", "never",
or "auto".
2. Add OPT_COLOR_FLAG(), OPT__COLOR(), and parse_opt_color_flag_cb()
to the option parsing library. The callback uses
git_config_colorbool(), so color.h is now a dependency
of parse-options.c.
Signed-off-by: Mark Lodato <lodatom@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2010-02-17 05:55:58 +01:00
|
|
|
OPT__COLOR(&branch_use_color, "use colored output"),
|
2011-08-28 16:54:30 +02:00
|
|
|
OPT_SET_INT('r', "remotes", &kinds, "act on remote-tracking branches",
|
2007-11-07 11:20:28 +01:00
|
|
|
REF_REMOTE_BRANCH),
|
2008-07-09 02:31:51 +02:00
|
|
|
{
|
|
|
|
|
OPTION_CALLBACK, 0, "contains", &with_commit, "commit",
|
|
|
|
|
"print only branches that contain the commit",
|
|
|
|
|
PARSE_OPT_LASTARG_DEFAULT,
|
2009-01-26 15:13:23 +01:00
|
|
|
parse_opt_with_commit, (intptr_t)"HEAD",
|
2008-07-09 02:31:51 +02:00
|
|
|
},
|
2007-11-07 23:58:09 +01:00
|
|
|
{
|
|
|
|
|
OPTION_CALLBACK, 0, "with", &with_commit, "commit",
|
|
|
|
|
"print only branches that contain the commit",
|
2008-07-09 02:31:51 +02:00
|
|
|
PARSE_OPT_HIDDEN | PARSE_OPT_LASTARG_DEFAULT,
|
2009-01-26 15:13:23 +01:00
|
|
|
parse_opt_with_commit, (intptr_t) "HEAD",
|
2007-11-07 23:58:09 +01:00
|
|
|
},
|
2007-10-07 18:26:21 +02:00
|
|
|
OPT__ABBREV(&abbrev),
|
|
|
|
|
|
|
|
|
|
OPT_GROUP("Specific git-branch actions:"),
|
2011-08-28 16:54:30 +02:00
|
|
|
OPT_SET_INT('a', "all", &kinds, "list both remote-tracking and local branches",
|
2007-11-07 11:20:28 +01:00
|
|
|
REF_REMOTE_BRANCH | REF_LOCAL_BRANCH),
|
2011-08-28 16:54:30 +02:00
|
|
|
OPT_BIT('d', "delete", &delete, "delete fully merged branch", 1),
|
2007-11-07 11:20:28 +01:00
|
|
|
OPT_BIT('D', NULL, &delete, "delete branch (even if not merged)", 2),
|
2011-08-28 16:54:30 +02:00
|
|
|
OPT_BIT('m', "move", &rename, "move/rename a branch and its reflog", 1),
|
2007-11-07 11:20:28 +01:00
|
|
|
OPT_BIT('M', NULL, &rename, "move/rename a branch, even if target exists", 2),
|
2011-08-28 16:54:31 +02:00
|
|
|
OPT_BOOLEAN(0, "list", &list, "list branch names"),
|
2011-08-28 16:54:30 +02:00
|
|
|
OPT_BOOLEAN('l', "create-reflog", &reflog, "create the branch's reflog"),
|
2010-11-08 19:01:54 +01:00
|
|
|
OPT__FORCE(&force_create, "force creation (when already exists)"),
|
2008-07-09 02:55:47 +02:00
|
|
|
{
|
|
|
|
|
OPTION_CALLBACK, 0, "no-merged", &merge_filter_ref,
|
|
|
|
|
"commit", "print only not merged branches",
|
|
|
|
|
PARSE_OPT_LASTARG_DEFAULT | PARSE_OPT_NONEG,
|
|
|
|
|
opt_parse_merge_filter, (intptr_t) "HEAD",
|
|
|
|
|
},
|
|
|
|
|
{
|
|
|
|
|
OPTION_CALLBACK, 0, "merged", &merge_filter_ref,
|
|
|
|
|
"commit", "print only merged branches",
|
|
|
|
|
PARSE_OPT_LASTARG_DEFAULT | PARSE_OPT_NONEG,
|
|
|
|
|
opt_parse_merge_filter, (intptr_t) "HEAD",
|
|
|
|
|
},
|
2007-10-07 18:26:21 +02:00
|
|
|
OPT_END(),
|
|
|
|
|
};
|
2006-10-23 23:27:45 +02:00
|
|
|
|
2010-10-22 08:42:58 +02:00
|
|
|
if (argc == 2 && !strcmp(argv[1], "-h"))
|
|
|
|
|
usage_with_options(builtin_branch_usage, options);
|
|
|
|
|
|
2008-05-14 19:46:53 +02:00
|
|
|
git_config(git_branch_config, NULL);
|
2008-02-18 08:26:03 +01:00
|
|
|
|
2008-02-19 17:24:37 +01:00
|
|
|
track = git_branch_track;
|
2006-11-28 15:47:40 +01:00
|
|
|
|
2007-05-20 14:19:17 +02:00
|
|
|
head = resolve_ref("HEAD", head_sha1, 0, NULL);
|
2006-10-23 23:27:45 +02:00
|
|
|
if (!head)
|
2011-02-23 00:41:34 +01:00
|
|
|
die(_("Failed to resolve HEAD as a valid ref."));
|
2007-05-20 14:19:17 +02:00
|
|
|
head = xstrdup(head);
|
2007-01-03 21:10:10 +01:00
|
|
|
if (!strcmp(head, "HEAD")) {
|
|
|
|
|
detached = 1;
|
2007-10-07 18:26:21 +02:00
|
|
|
} else {
|
Mechanical conversion to use prefixcmp()
This mechanically converts strncmp() to use prefixcmp(), but only when
the parameters match specific patterns, so that they can be verified
easily. Leftover from this will be fixed in a separate step, including
idiotic conversions like
if (!strncmp("foo", arg, 3))
=>
if (!(-prefixcmp(arg, "foo")))
This was done by using this script in px.perl
#!/usr/bin/perl -i.bak -p
if (/strncmp\(([^,]+), "([^\\"]*)", (\d+)\)/ && (length($2) == $3)) {
s|strncmp\(([^,]+), "([^\\"]*)", (\d+)\)|prefixcmp($1, "$2")|;
}
if (/strncmp\("([^\\"]*)", ([^,]+), (\d+)\)/ && (length($1) == $3)) {
s|strncmp\("([^\\"]*)", ([^,]+), (\d+)\)|(-prefixcmp($2, "$1"))|;
}
and running:
$ git grep -l strncmp -- '*.c' | xargs perl px.perl
Signed-off-by: Junio C Hamano <junkio@cox.net>
2007-02-20 10:53:29 +01:00
|
|
|
if (prefixcmp(head, "refs/heads/"))
|
2011-02-23 00:41:34 +01:00
|
|
|
die(_("HEAD not found below refs/heads!"));
|
2007-01-03 21:10:10 +01:00
|
|
|
head += 11;
|
|
|
|
|
}
|
2008-07-09 02:55:47 +02:00
|
|
|
hashcpy(merge_filter_ref, head_sha1);
|
|
|
|
|
|
2009-05-23 20:53:12 +02:00
|
|
|
argc = parse_options(argc, argv, prefix, options, builtin_branch_usage,
|
|
|
|
|
0);
|
2011-08-28 16:54:31 +02:00
|
|
|
|
2011-09-08 23:09:50 +02:00
|
|
|
if (!delete && !rename && !force_create && argc == 0)
|
2011-08-28 16:54:31 +02:00
|
|
|
list = 1;
|
|
|
|
|
|
|
|
|
|
if (!!delete + !!rename + !!force_create + !!list > 1)
|
2008-07-09 02:55:47 +02:00
|
|
|
usage_with_options(builtin_branch_usage, options);
|
2006-10-23 23:27:45 +02:00
|
|
|
|
2011-07-01 08:06:08 +02:00
|
|
|
if (abbrev == -1)
|
|
|
|
|
abbrev = DEFAULT_ABBREV;
|
|
|
|
|
|
2006-10-23 23:27:45 +02:00
|
|
|
if (delete)
|
2007-11-07 11:20:28 +01:00
|
|
|
return delete_branches(argc, argv, delete > 1, kinds);
|
2011-08-28 16:54:31 +02:00
|
|
|
else if (list)
|
2011-08-28 16:54:32 +02:00
|
|
|
return print_ref_list(kinds, detached, verbose, abbrev,
|
|
|
|
|
with_commit, argv);
|
2011-11-02 17:17:12 +01:00
|
|
|
else if (rename) {
|
|
|
|
|
if (argc == 1)
|
|
|
|
|
rename_branch(head, argv[0], rename > 1);
|
|
|
|
|
else if (argc == 2)
|
|
|
|
|
rename_branch(argv[0], argv[1], rename > 1);
|
|
|
|
|
else
|
|
|
|
|
usage_with_options(builtin_branch_usage, options);
|
|
|
|
|
} else if (argc <= 2) {
|
2009-12-30 15:45:31 +01:00
|
|
|
if (kinds != REF_LOCAL_BRANCH)
|
2011-02-23 00:41:34 +01:00
|
|
|
die(_("-a and -r options to 'git branch' do not make sense with a branch name"));
|
2008-02-07 17:40:08 +01:00
|
|
|
create_branch(head, argv[0], (argc == 2) ? argv[1] : head,
|
2007-03-08 22:59:54 +01:00
|
|
|
force_create, reflog, track);
|
2009-12-30 15:45:31 +01:00
|
|
|
} else
|
2007-10-07 18:26:21 +02:00
|
|
|
usage_with_options(builtin_branch_usage, options);
|
2006-10-23 23:27:45 +02:00
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|