2009-10-19 12:38:32 +00:00
|
|
|
#include "cache.h"
|
2015-08-18 00:21:59 +00:00
|
|
|
#include "submodule-config.h"
|
2009-10-19 12:38:32 +00:00
|
|
|
#include "submodule.h"
|
|
|
|
#include "dir.h"
|
|
|
|
#include "diff.h"
|
|
|
|
#include "commit.h"
|
|
|
|
#include "revision.h"
|
2010-01-16 17:42:24 +00:00
|
|
|
#include "run-command.h"
|
2010-03-04 21:20:33 +00:00
|
|
|
#include "diffcore.h"
|
2010-07-07 13:39:13 +00:00
|
|
|
#include "refs.h"
|
2010-08-05 22:39:25 +00:00
|
|
|
#include "string-list.h"
|
2011-09-12 19:56:52 +00:00
|
|
|
#include "sha1-array.h"
|
2011-09-13 21:57:57 +00:00
|
|
|
#include "argv-array.h"
|
2013-07-30 19:50:34 +00:00
|
|
|
#include "blob.h"
|
2015-12-16 00:04:11 +00:00
|
|
|
#include "thread-utils.h"
|
2016-04-28 13:38:20 +00:00
|
|
|
#include "quote.h"
|
2010-08-05 22:39:25 +00:00
|
|
|
|
2011-03-06 22:10:46 +00:00
|
|
|
static int config_fetch_recurse_submodules = RECURSE_SUBMODULES_ON_DEMAND;
|
2016-03-01 02:07:13 +00:00
|
|
|
static int parallel_jobs = 1;
|
2016-06-13 10:04:20 +00:00
|
|
|
static struct string_list changed_submodule_paths = STRING_LIST_INIT_NODUP;
|
2011-09-12 19:56:52 +00:00
|
|
|
static int initialized_fetch_ref_tips;
|
|
|
|
static struct sha1_array ref_tips_before_fetch;
|
|
|
|
static struct sha1_array ref_tips_after_fetch;
|
|
|
|
|
2011-05-14 16:26:58 +00:00
|
|
|
/*
|
|
|
|
* The following flag is set if the .gitmodules file is unmerged. We then
|
|
|
|
* disable recursion for all submodules where .git/config doesn't have a
|
|
|
|
* matching config entry because we can't guess what might be configured in
|
|
|
|
* .gitmodules unless the user resolves the conflict. When a command line
|
|
|
|
* option is given (which always overrides configuration) this flag will be
|
|
|
|
* ignored.
|
|
|
|
*/
|
|
|
|
static int gitmodules_is_unmerged;
|
2009-10-19 12:38:32 +00:00
|
|
|
|
2013-07-30 19:50:34 +00:00
|
|
|
/*
|
|
|
|
* This flag is set if the .gitmodules file had unstaged modifications on
|
|
|
|
* startup. This must be checked before allowing modifications to the
|
|
|
|
* .gitmodules file with the intention to stage them later, because when
|
|
|
|
* continuing we would stage the modifications the user didn't stage herself
|
|
|
|
* too. That might change in a future version when we learn to stage the
|
|
|
|
* changes we do ourselves without staging any previous modifications.
|
|
|
|
*/
|
|
|
|
static int gitmodules_is_modified;
|
|
|
|
|
|
|
|
int is_staging_gitmodules_ok(void)
|
|
|
|
{
|
|
|
|
return !gitmodules_is_modified;
|
|
|
|
}
|
|
|
|
|
2013-08-06 19:15:11 +00:00
|
|
|
/*
|
|
|
|
* Try to update the "path" entry in the "submodule.<name>" section of the
|
|
|
|
* .gitmodules file. Return 0 only if a .gitmodules file was found, a section
|
|
|
|
* with the correct path=<oldpath> setting was found and we could update it.
|
|
|
|
*/
|
|
|
|
int update_path_in_gitmodules(const char *oldpath, const char *newpath)
|
|
|
|
{
|
|
|
|
struct strbuf entry = STRBUF_INIT;
|
2015-08-18 00:21:59 +00:00
|
|
|
const struct submodule *submodule;
|
2013-08-06 19:15:11 +00:00
|
|
|
|
|
|
|
if (!file_exists(".gitmodules")) /* Do nothing without .gitmodules */
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
if (gitmodules_is_unmerged)
|
|
|
|
die(_("Cannot change unmerged .gitmodules, resolve merge conflicts first"));
|
|
|
|
|
2015-08-18 00:21:59 +00:00
|
|
|
submodule = submodule_from_path(null_sha1, oldpath);
|
|
|
|
if (!submodule || !submodule->name) {
|
2013-08-06 19:15:11 +00:00
|
|
|
warning(_("Could not find section in .gitmodules where path=%s"), oldpath);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
strbuf_addstr(&entry, "submodule.");
|
2015-08-18 00:21:59 +00:00
|
|
|
strbuf_addstr(&entry, submodule->name);
|
2013-08-06 19:15:11 +00:00
|
|
|
strbuf_addstr(&entry, ".path");
|
2016-02-22 11:23:35 +00:00
|
|
|
if (git_config_set_in_file_gently(".gitmodules", entry.buf, newpath) < 0) {
|
2013-08-06 19:15:11 +00:00
|
|
|
/* Maybe the user already did that, don't error out here */
|
|
|
|
warning(_("Could not update .gitmodules entry %s"), entry.buf);
|
|
|
|
strbuf_release(&entry);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
strbuf_release(&entry);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-08-06 19:15:25 +00:00
|
|
|
/*
|
|
|
|
* Try to remove the "submodule.<name>" section from .gitmodules where the given
|
|
|
|
* path is configured. Return 0 only if a .gitmodules file was found, a section
|
|
|
|
* with the correct path=<path> setting was found and we could remove it.
|
|
|
|
*/
|
|
|
|
int remove_path_from_gitmodules(const char *path)
|
|
|
|
{
|
|
|
|
struct strbuf sect = STRBUF_INIT;
|
2015-08-18 00:21:59 +00:00
|
|
|
const struct submodule *submodule;
|
2013-08-06 19:15:25 +00:00
|
|
|
|
|
|
|
if (!file_exists(".gitmodules")) /* Do nothing without .gitmodules */
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
if (gitmodules_is_unmerged)
|
|
|
|
die(_("Cannot change unmerged .gitmodules, resolve merge conflicts first"));
|
|
|
|
|
2015-08-18 00:21:59 +00:00
|
|
|
submodule = submodule_from_path(null_sha1, path);
|
|
|
|
if (!submodule || !submodule->name) {
|
2013-08-06 19:15:25 +00:00
|
|
|
warning(_("Could not find section in .gitmodules where path=%s"), path);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
strbuf_addstr(§, "submodule.");
|
2015-08-18 00:21:59 +00:00
|
|
|
strbuf_addstr(§, submodule->name);
|
2013-08-06 19:15:25 +00:00
|
|
|
if (git_config_rename_section_in_file(".gitmodules", sect.buf, NULL) < 0) {
|
|
|
|
/* Maybe the user already did that, don't error out here */
|
|
|
|
warning(_("Could not remove .gitmodules entry for %s"), path);
|
|
|
|
strbuf_release(§);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
strbuf_release(§);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-07-30 19:50:34 +00:00
|
|
|
void stage_updated_gitmodules(void)
|
|
|
|
{
|
2013-11-07 14:33:43 +00:00
|
|
|
if (add_file_to_cache(".gitmodules", 0))
|
2013-07-30 19:50:34 +00:00
|
|
|
die(_("staging updated .gitmodules failed"));
|
|
|
|
}
|
|
|
|
|
2010-01-12 06:31:58 +00:00
|
|
|
static int add_submodule_odb(const char *path)
|
2009-10-19 12:38:32 +00:00
|
|
|
{
|
|
|
|
struct strbuf objects_directory = STRBUF_INIT;
|
|
|
|
struct alternate_object_database *alt_odb;
|
2010-01-31 16:43:49 +00:00
|
|
|
int ret = 0;
|
2016-02-22 22:44:35 +00:00
|
|
|
size_t alloc;
|
2009-10-19 12:38:32 +00:00
|
|
|
|
2016-08-31 23:27:22 +00:00
|
|
|
ret = strbuf_git_path_submodule(&objects_directory, path, "objects/");
|
|
|
|
if (ret)
|
|
|
|
goto done;
|
2010-01-31 16:43:49 +00:00
|
|
|
if (!is_directory(objects_directory.buf)) {
|
|
|
|
ret = -1;
|
|
|
|
goto done;
|
|
|
|
}
|
2009-10-19 12:38:32 +00:00
|
|
|
/* avoid adding it twice */
|
add_submodule_odb: initialize alt_odb list earlier
The add_submodule_odb function tries to add a submodule's
object store as an "alternate". It needs the existing list
to be initialized (from the objects/info/alternates file)
for two reasons:
1. We look for duplicates with the existing alternate
stores, but obviously this doesn't work if we haven't
loaded any yet.
2. We link our new entry into the list by prepending it to
alt_odb_list. But we do _not_ modify alt_odb_tail.
This variable starts as NULL, and is a signal to the
alt_odb code that the list has not yet been
initialized.
We then call read_info_alternates on the submodule (to
recursively load its alternates), which will try to
append to that tail, assuming it has been initialized.
This causes us to segfault if it is NULL.
This rarely comes up in practice, because we will have
initialized the alt_odb any time we do an object lookup. So
you can trigger this only when:
- you try to access a submodule (e.g., a diff with
diff.submodule=log)
- the access happens before any other object has been
accessed (e.g., because the diff is between the working
tree and the index)
- the submodule contains an alternates file (so we try to
add an entry to the NULL alt_odb_tail)
To fix this, we just need to call prepare_alt_odb at the
start of the function (and if we have already initialized,
it is a noop).
Note that we can remove the prepare_alt_odb call from the
end. It is guaranteed to be a noop, since we will have
called it earlier.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2015-10-28 14:07:25 +00:00
|
|
|
prepare_alt_odb();
|
2009-10-19 12:38:32 +00:00
|
|
|
for (alt_odb = alt_odb_list; alt_odb; alt_odb = alt_odb->next)
|
|
|
|
if (alt_odb->name - alt_odb->base == objects_directory.len &&
|
|
|
|
!strncmp(alt_odb->base, objects_directory.buf,
|
|
|
|
objects_directory.len))
|
2010-01-31 16:43:49 +00:00
|
|
|
goto done;
|
2009-10-19 12:38:32 +00:00
|
|
|
|
2016-02-22 22:44:35 +00:00
|
|
|
alloc = st_add(objects_directory.len, 42); /* for "12/345..." sha1 */
|
|
|
|
alt_odb = xmalloc(st_add(sizeof(*alt_odb), alloc));
|
2009-10-19 12:38:32 +00:00
|
|
|
alt_odb->next = alt_odb_list;
|
avoid sprintf and strcpy with flex arrays
When we are allocating a struct with a FLEX_ARRAY member, we
generally compute the size of the array and then sprintf or
strcpy into it. Normally we could improve a dynamic allocation
like this by using xstrfmt, but it doesn't work here; we
have to account for the size of the rest of the struct.
But we can improve things a bit by storing the length that
we use for the allocation, and then feeding it to xsnprintf
or memcpy, which makes it more obvious that we are not
writing more than the allocated number of bytes.
It would be nice if we had some kind of helper for
allocating generic flex arrays, but it doesn't work that
well:
- the call signature is a little bit unwieldy:
d = flex_struct(sizeof(*d), offsetof(d, path), fmt, ...);
You need offsetof here instead of just writing to the
end of the base size, because we don't know how the
struct is packed (partially this is because FLEX_ARRAY
might not be zero, though we can account for that; but
the size of the struct may actually be rounded up for
alignment, and we can't know that).
- some sites do clever things, like over-allocating because
they know they will write larger things into the buffer
later (e.g., struct packed_git here).
So we're better off to just write out each allocation (or
add type-specific helpers, though many of these are one-off
allocations anyway).
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2015-09-24 21:08:12 +00:00
|
|
|
xsnprintf(alt_odb->base, alloc, "%s", objects_directory.buf);
|
2009-10-19 12:38:32 +00:00
|
|
|
alt_odb->name = alt_odb->base + objects_directory.len;
|
|
|
|
alt_odb->name[2] = '/';
|
|
|
|
alt_odb->name[40] = '\0';
|
|
|
|
alt_odb->name[41] = '\0';
|
|
|
|
alt_odb_list = alt_odb;
|
2012-05-14 16:24:45 +00:00
|
|
|
|
|
|
|
/* add possible alternates from the submodule */
|
|
|
|
read_info_alternates(objects_directory.buf, 0);
|
2010-01-31 16:43:49 +00:00
|
|
|
done:
|
|
|
|
strbuf_release(&objects_directory);
|
|
|
|
return ret;
|
2009-10-19 12:38:32 +00:00
|
|
|
}
|
|
|
|
|
2010-08-05 22:39:25 +00:00
|
|
|
void set_diffopt_flags_from_submodule_config(struct diff_options *diffopt,
|
|
|
|
const char *path)
|
|
|
|
{
|
2015-08-18 00:21:59 +00:00
|
|
|
const struct submodule *submodule = submodule_from_path(null_sha1, path);
|
|
|
|
if (submodule) {
|
|
|
|
if (submodule->ignore)
|
|
|
|
handle_ignore_submodules_arg(diffopt, submodule->ignore);
|
2011-05-14 16:26:58 +00:00
|
|
|
else if (gitmodules_is_unmerged)
|
|
|
|
DIFF_OPT_SET(diffopt, IGNORE_SUBMODULES);
|
2010-08-05 22:39:25 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-11-12 12:54:52 +00:00
|
|
|
int submodule_config(const char *var, const char *value, void *cb)
|
2010-08-05 22:40:48 +00:00
|
|
|
{
|
2016-03-01 02:07:13 +00:00
|
|
|
if (!strcmp(var, "submodule.fetchjobs")) {
|
|
|
|
parallel_jobs = git_config_int(var, value);
|
|
|
|
if (parallel_jobs < 0)
|
|
|
|
die(_("negative values not allowed for submodule.fetchJobs"));
|
|
|
|
return 0;
|
|
|
|
} else if (starts_with(var, "submodule."))
|
2010-08-05 22:40:48 +00:00
|
|
|
return parse_submodule_config_option(var, value);
|
2010-11-10 23:55:02 +00:00
|
|
|
else if (!strcmp(var, "fetch.recursesubmodules")) {
|
2011-03-06 22:11:48 +00:00
|
|
|
config_fetch_recurse_submodules = parse_fetch_recurse_submodules_arg(var, value);
|
2010-11-10 23:55:02 +00:00
|
|
|
return 0;
|
|
|
|
}
|
2010-08-05 22:40:48 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
void gitmodules_config(void)
|
|
|
|
{
|
|
|
|
const char *work_tree = get_git_work_tree();
|
|
|
|
if (work_tree) {
|
|
|
|
struct strbuf gitmodules_path = STRBUF_INIT;
|
2011-05-14 16:26:58 +00:00
|
|
|
int pos;
|
2010-08-05 22:40:48 +00:00
|
|
|
strbuf_addstr(&gitmodules_path, work_tree);
|
|
|
|
strbuf_addstr(&gitmodules_path, "/.gitmodules");
|
2011-05-14 16:26:58 +00:00
|
|
|
if (read_cache() < 0)
|
|
|
|
die("index file corrupt");
|
|
|
|
pos = cache_name_pos(".gitmodules", 11);
|
|
|
|
if (pos < 0) { /* .gitmodules not found or isn't merged */
|
|
|
|
pos = -1 - pos;
|
|
|
|
if (active_nr > pos) { /* there is a .gitmodules */
|
|
|
|
const struct cache_entry *ce = active_cache[pos];
|
|
|
|
if (ce_namelen(ce) == 11 &&
|
|
|
|
!memcmp(ce->name, ".gitmodules", 11))
|
|
|
|
gitmodules_is_unmerged = 1;
|
|
|
|
}
|
2013-07-30 19:50:34 +00:00
|
|
|
} else if (pos < active_nr) {
|
|
|
|
struct stat st;
|
|
|
|
if (lstat(".gitmodules", &st) == 0 &&
|
|
|
|
ce_match_stat(active_cache[pos], &st, 0) & DATA_CHANGED)
|
|
|
|
gitmodules_is_modified = 1;
|
2011-05-14 16:26:58 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (!gitmodules_is_unmerged)
|
|
|
|
git_config_from_file(submodule_config, gitmodules_path.buf, NULL);
|
2010-08-05 22:40:48 +00:00
|
|
|
strbuf_release(&gitmodules_path);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-03-01 02:07:11 +00:00
|
|
|
int parse_submodule_update_strategy(const char *value,
|
|
|
|
struct submodule_update_strategy *dst)
|
|
|
|
{
|
|
|
|
free((void*)dst->command);
|
|
|
|
dst->command = NULL;
|
|
|
|
if (!strcmp(value, "none"))
|
|
|
|
dst->type = SM_UPDATE_NONE;
|
|
|
|
else if (!strcmp(value, "checkout"))
|
|
|
|
dst->type = SM_UPDATE_CHECKOUT;
|
|
|
|
else if (!strcmp(value, "rebase"))
|
|
|
|
dst->type = SM_UPDATE_REBASE;
|
|
|
|
else if (!strcmp(value, "merge"))
|
|
|
|
dst->type = SM_UPDATE_MERGE;
|
|
|
|
else if (skip_prefix(value, "!", &value)) {
|
|
|
|
dst->type = SM_UPDATE_COMMAND;
|
|
|
|
dst->command = xstrdup(value);
|
|
|
|
} else
|
|
|
|
return -1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
submodule: port init from shell to C
By having the `submodule init` functionality in C, we can reference it
easier from other parts in the code in later patches. The code is split
up to have one function to initialize one submodule and a calling function
that takes care of the rest, such as argument handling and translating the
arguments to the paths of the submodules.
This is the first submodule subcommand that is fully converted to C
except for the usage string, so this is actually removing a call to
the `submodule--helper list` function, which is supposed to be used in
this transition. Instead we'll make a direct call to `module_list_compute`.
An explanation why we need to edit the prefixes in cmd_update in
git-submodule.sh in this patch:
By having no processing in the shell part, we need to convey the notion
of wt_prefix and prefix to the C parts, which former patches punted on
and did the processing of displaying path in the shell.
`wt_prefix` used to hold the path from the repository root to the current
directory, e.g. wt_prefix would be t/ if the user invoked the
`git submodule` command in ~/repo/t and ~repo is the GIT_DIR.
`prefix` used to hold the relative path from the repository root to the
operation, e.g. if you have recursive submodules, the shell script would
modify the `prefix` in each recursive step by adding the submodule path.
We will pass `wt_prefix` into the C helper via `git -C <dir>` as that
will setup git in the directory the user actually called git-submodule.sh
from. The `prefix` will be passed in via the `--prefix` option.
Having `prefix` and `wt_prefix` relative to the GIT_DIR of the
calling superproject is unfortunate with this patch as the C code doesn't
know about a possible recursion from a superproject via `submodule update
--init --recursive`.
To fix this, we change the meaning of `wt_prefix` to point to the current
project instead of the superproject and `prefix` to include any relative
paths issues in the superproject. That way `prefix` will become the leading
part for displaying paths and `wt_prefix` will be empty in recursive
calls for now.
The new notion of `wt_prefix` and `prefix` still allows us to reconstruct
the calling directory in the superproject by just traveling reverse of
`prefix`.
Signed-off-by: Stefan Beller <sbeller@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-04-16 00:50:13 +00:00
|
|
|
const char *submodule_strategy_to_string(const struct submodule_update_strategy *s)
|
|
|
|
{
|
|
|
|
struct strbuf sb = STRBUF_INIT;
|
|
|
|
switch (s->type) {
|
|
|
|
case SM_UPDATE_CHECKOUT:
|
|
|
|
return "checkout";
|
|
|
|
case SM_UPDATE_MERGE:
|
|
|
|
return "merge";
|
|
|
|
case SM_UPDATE_REBASE:
|
|
|
|
return "rebase";
|
|
|
|
case SM_UPDATE_NONE:
|
|
|
|
return "none";
|
|
|
|
case SM_UPDATE_UNSPECIFIED:
|
|
|
|
return NULL;
|
|
|
|
case SM_UPDATE_COMMAND:
|
|
|
|
strbuf_addf(&sb, "!%s", s->command);
|
|
|
|
return strbuf_detach(&sb, NULL);
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2010-06-25 14:56:47 +00:00
|
|
|
void handle_ignore_submodules_arg(struct diff_options *diffopt,
|
|
|
|
const char *arg)
|
|
|
|
{
|
2010-08-05 08:49:55 +00:00
|
|
|
DIFF_OPT_CLR(diffopt, IGNORE_SUBMODULES);
|
|
|
|
DIFF_OPT_CLR(diffopt, IGNORE_UNTRACKED_IN_SUBMODULES);
|
|
|
|
DIFF_OPT_CLR(diffopt, IGNORE_DIRTY_SUBMODULES);
|
|
|
|
|
2010-06-25 14:56:47 +00:00
|
|
|
if (!strcmp(arg, "all"))
|
|
|
|
DIFF_OPT_SET(diffopt, IGNORE_SUBMODULES);
|
|
|
|
else if (!strcmp(arg, "untracked"))
|
|
|
|
DIFF_OPT_SET(diffopt, IGNORE_UNTRACKED_IN_SUBMODULES);
|
|
|
|
else if (!strcmp(arg, "dirty"))
|
|
|
|
DIFF_OPT_SET(diffopt, IGNORE_DIRTY_SUBMODULES);
|
2010-08-05 22:39:25 +00:00
|
|
|
else if (strcmp(arg, "none"))
|
2010-06-25 14:56:47 +00:00
|
|
|
die("bad --ignore-submodules argument: %s", arg);
|
|
|
|
}
|
|
|
|
|
2011-03-16 07:14:11 +00:00
|
|
|
static int prepare_submodule_summary(struct rev_info *rev, const char *path,
|
|
|
|
struct commit *left, struct commit *right,
|
2016-08-31 23:27:24 +00:00
|
|
|
struct commit_list *merge_bases)
|
2011-03-16 07:14:11 +00:00
|
|
|
{
|
2016-08-31 23:27:24 +00:00
|
|
|
struct commit_list *list;
|
2011-03-16 07:14:11 +00:00
|
|
|
|
|
|
|
init_revisions(rev, NULL);
|
|
|
|
setup_revisions(0, NULL, rev, NULL);
|
|
|
|
rev->left_right = 1;
|
|
|
|
rev->first_parent_only = 1;
|
|
|
|
left->object.flags |= SYMMETRIC_LEFT;
|
|
|
|
add_pending_object(rev, &left->object, path);
|
|
|
|
add_pending_object(rev, &right->object, path);
|
|
|
|
for (list = merge_bases; list; list = list->next) {
|
|
|
|
list->item->object.flags |= UNINTERESTING;
|
|
|
|
add_pending_object(rev, &list->item->object,
|
2015-11-10 02:22:28 +00:00
|
|
|
oid_to_hex(&list->item->object.oid));
|
2011-03-16 07:14:11 +00:00
|
|
|
}
|
|
|
|
return prepare_revision_walk(rev);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void print_submodule_summary(struct rev_info *rev, FILE *f,
|
2013-04-05 16:12:08 +00:00
|
|
|
const char *line_prefix,
|
2011-03-16 07:14:11 +00:00
|
|
|
const char *del, const char *add, const char *reset)
|
|
|
|
{
|
|
|
|
static const char format[] = " %m %s";
|
|
|
|
struct strbuf sb = STRBUF_INIT;
|
|
|
|
struct commit *commit;
|
|
|
|
|
|
|
|
while ((commit = get_revision(rev))) {
|
|
|
|
struct pretty_print_context ctx = {0};
|
|
|
|
ctx.date_mode = rev->date_mode;
|
2013-06-26 10:19:50 +00:00
|
|
|
ctx.output_encoding = get_log_output_encoding();
|
2011-03-16 07:14:11 +00:00
|
|
|
strbuf_setlen(&sb, 0);
|
2013-04-05 16:12:08 +00:00
|
|
|
strbuf_addstr(&sb, line_prefix);
|
2011-03-16 07:14:11 +00:00
|
|
|
if (commit->object.flags & SYMMETRIC_LEFT) {
|
|
|
|
if (del)
|
|
|
|
strbuf_addstr(&sb, del);
|
|
|
|
}
|
|
|
|
else if (add)
|
|
|
|
strbuf_addstr(&sb, add);
|
|
|
|
format_commit_message(commit, format, &sb, &ctx);
|
|
|
|
if (reset)
|
|
|
|
strbuf_addstr(&sb, reset);
|
|
|
|
strbuf_addch(&sb, '\n');
|
|
|
|
fprintf(f, "%s", sb.buf);
|
|
|
|
}
|
|
|
|
strbuf_release(&sb);
|
|
|
|
}
|
|
|
|
|
2016-08-31 23:27:24 +00:00
|
|
|
/* Helper function to display the submodule header line prior to the full
|
|
|
|
* summary output. If it can locate the submodule objects directory it will
|
|
|
|
* attempt to lookup both the left and right commits and put them into the
|
|
|
|
* left and right pointers.
|
|
|
|
*/
|
|
|
|
static void show_submodule_header(FILE *f, const char *path,
|
2013-04-05 16:12:08 +00:00
|
|
|
const char *line_prefix,
|
2016-08-31 23:27:23 +00:00
|
|
|
struct object_id *one, struct object_id *two,
|
2012-11-13 15:42:47 +00:00
|
|
|
unsigned dirty_submodule, const char *meta,
|
2016-08-31 23:27:24 +00:00
|
|
|
const char *reset,
|
|
|
|
struct commit **left, struct commit **right,
|
|
|
|
struct commit_list **merge_bases)
|
2009-10-19 12:38:32 +00:00
|
|
|
{
|
|
|
|
const char *message = NULL;
|
|
|
|
struct strbuf sb = STRBUF_INIT;
|
|
|
|
int fast_forward = 0, fast_backward = 0;
|
|
|
|
|
2010-03-04 21:20:33 +00:00
|
|
|
if (dirty_submodule & DIRTY_SUBMODULE_UNTRACKED)
|
2013-04-05 16:12:08 +00:00
|
|
|
fprintf(f, "%sSubmodule %s contains untracked content\n",
|
|
|
|
line_prefix, path);
|
2010-03-04 21:20:33 +00:00
|
|
|
if (dirty_submodule & DIRTY_SUBMODULE_MODIFIED)
|
2013-04-05 16:12:08 +00:00
|
|
|
fprintf(f, "%sSubmodule %s contains modified content\n",
|
|
|
|
line_prefix, path);
|
2010-03-04 21:20:33 +00:00
|
|
|
|
2016-08-31 23:27:24 +00:00
|
|
|
if (is_null_oid(one))
|
|
|
|
message = "(new submodule)";
|
|
|
|
else if (is_null_oid(two))
|
|
|
|
message = "(submodule deleted)";
|
|
|
|
|
|
|
|
if (add_submodule_odb(path)) {
|
|
|
|
if (!message)
|
|
|
|
message = "(not initialized)";
|
|
|
|
goto output_header;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Attempt to lookup the commit references, and determine if this is
|
|
|
|
* a fast forward or fast backwards update.
|
|
|
|
*/
|
|
|
|
*left = lookup_commit_reference(one->hash);
|
|
|
|
*right = lookup_commit_reference(two->hash);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Warn about missing commits in the submodule project, but only if
|
|
|
|
* they aren't null.
|
|
|
|
*/
|
|
|
|
if ((!is_null_oid(one) && !*left) ||
|
|
|
|
(!is_null_oid(two) && !*right))
|
|
|
|
message = "(commits not present)";
|
|
|
|
|
|
|
|
*merge_bases = get_merge_bases(*left, *right);
|
|
|
|
if (*merge_bases) {
|
|
|
|
if ((*merge_bases)->item == *left)
|
|
|
|
fast_forward = 1;
|
|
|
|
else if ((*merge_bases)->item == *right)
|
|
|
|
fast_backward = 1;
|
|
|
|
}
|
|
|
|
|
2016-08-31 23:27:23 +00:00
|
|
|
if (!oidcmp(one, two)) {
|
2010-03-04 21:20:33 +00:00
|
|
|
strbuf_release(&sb);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2016-08-31 23:27:24 +00:00
|
|
|
output_header:
|
2013-04-05 16:12:08 +00:00
|
|
|
strbuf_addf(&sb, "%s%sSubmodule %s %s..", line_prefix, meta, path,
|
2016-08-31 23:27:23 +00:00
|
|
|
find_unique_abbrev(one->hash, DEFAULT_ABBREV));
|
2009-10-19 12:38:32 +00:00
|
|
|
if (!fast_backward && !fast_forward)
|
|
|
|
strbuf_addch(&sb, '.');
|
2016-08-31 23:27:23 +00:00
|
|
|
strbuf_addf(&sb, "%s", find_unique_abbrev(two->hash, DEFAULT_ABBREV));
|
2009-10-19 12:38:32 +00:00
|
|
|
if (message)
|
2012-11-13 15:42:47 +00:00
|
|
|
strbuf_addf(&sb, " %s%s\n", message, reset);
|
2009-10-19 12:38:32 +00:00
|
|
|
else
|
2012-11-13 15:42:47 +00:00
|
|
|
strbuf_addf(&sb, "%s:%s\n", fast_backward ? " (rewind)" : "", reset);
|
2009-10-19 12:38:32 +00:00
|
|
|
fwrite(sb.buf, sb.len, 1, f);
|
|
|
|
|
|
|
|
strbuf_release(&sb);
|
|
|
|
}
|
2010-01-16 17:42:24 +00:00
|
|
|
|
2016-08-31 23:27:24 +00:00
|
|
|
void show_submodule_summary(FILE *f, const char *path,
|
|
|
|
const char *line_prefix,
|
|
|
|
struct object_id *one, struct object_id *two,
|
|
|
|
unsigned dirty_submodule, const char *meta,
|
|
|
|
const char *del, const char *add, const char *reset)
|
|
|
|
{
|
|
|
|
struct rev_info rev;
|
|
|
|
struct commit *left = NULL, *right = NULL;
|
|
|
|
struct commit_list *merge_bases = NULL;
|
|
|
|
|
|
|
|
show_submodule_header(f, path, line_prefix, one, two, dirty_submodule,
|
|
|
|
meta, reset, &left, &right, &merge_bases);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If we don't have both a left and a right pointer, there is no
|
|
|
|
* reason to try and display a summary. The header line should contain
|
|
|
|
* all the information the user needs.
|
|
|
|
*/
|
|
|
|
if (!left || !right)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
/* Treat revision walker failure the same as missing commits */
|
|
|
|
if (prepare_submodule_summary(&rev, path, left, right, merge_bases)) {
|
|
|
|
fprintf(f, "%s(revision walker failed)\n", line_prefix);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
print_submodule_summary(&rev, f, line_prefix, del, add, reset);
|
|
|
|
|
|
|
|
out:
|
|
|
|
if (merge_bases)
|
|
|
|
free_commit_list(merge_bases);
|
|
|
|
clear_commit_marks(left, ~0);
|
|
|
|
clear_commit_marks(right, ~0);
|
|
|
|
}
|
|
|
|
|
2016-08-31 23:27:25 +00:00
|
|
|
void show_submodule_inline_diff(FILE *f, const char *path,
|
|
|
|
const char *line_prefix,
|
|
|
|
struct object_id *one, struct object_id *two,
|
|
|
|
unsigned dirty_submodule, const char *meta,
|
|
|
|
const char *del, const char *add, const char *reset,
|
|
|
|
const struct diff_options *o)
|
|
|
|
{
|
|
|
|
const struct object_id *old = &empty_tree_oid, *new = &empty_tree_oid;
|
|
|
|
struct commit *left = NULL, *right = NULL;
|
|
|
|
struct commit_list *merge_bases = NULL;
|
|
|
|
struct strbuf submodule_dir = STRBUF_INIT;
|
|
|
|
struct child_process cp = CHILD_PROCESS_INIT;
|
|
|
|
|
|
|
|
show_submodule_header(f, path, line_prefix, one, two, dirty_submodule,
|
|
|
|
meta, reset, &left, &right, &merge_bases);
|
|
|
|
|
|
|
|
/* We need a valid left and right commit to display a difference */
|
|
|
|
if (!(left || is_null_oid(one)) ||
|
|
|
|
!(right || is_null_oid(two)))
|
|
|
|
goto done;
|
|
|
|
|
|
|
|
if (left)
|
|
|
|
old = one;
|
|
|
|
if (right)
|
|
|
|
new = two;
|
|
|
|
|
|
|
|
fflush(f);
|
|
|
|
cp.git_cmd = 1;
|
|
|
|
cp.dir = path;
|
|
|
|
cp.out = dup(fileno(f));
|
|
|
|
cp.no_stdin = 1;
|
|
|
|
|
|
|
|
/* TODO: other options may need to be passed here. */
|
|
|
|
argv_array_push(&cp.args, "diff");
|
|
|
|
argv_array_pushf(&cp.args, "--line-prefix=%s", line_prefix);
|
|
|
|
if (DIFF_OPT_TST(o, REVERSE_DIFF)) {
|
|
|
|
argv_array_pushf(&cp.args, "--src-prefix=%s%s/",
|
|
|
|
o->b_prefix, path);
|
|
|
|
argv_array_pushf(&cp.args, "--dst-prefix=%s%s/",
|
|
|
|
o->a_prefix, path);
|
|
|
|
} else {
|
|
|
|
argv_array_pushf(&cp.args, "--src-prefix=%s%s/",
|
|
|
|
o->a_prefix, path);
|
|
|
|
argv_array_pushf(&cp.args, "--dst-prefix=%s%s/",
|
|
|
|
o->b_prefix, path);
|
|
|
|
}
|
|
|
|
argv_array_push(&cp.args, oid_to_hex(old));
|
|
|
|
/*
|
|
|
|
* If the submodule has modified content, we will diff against the
|
|
|
|
* work tree, under the assumption that the user has asked for the
|
|
|
|
* diff format and wishes to actually see all differences even if they
|
|
|
|
* haven't yet been committed to the submodule yet.
|
|
|
|
*/
|
|
|
|
if (!(dirty_submodule & DIRTY_SUBMODULE_MODIFIED))
|
|
|
|
argv_array_push(&cp.args, oid_to_hex(new));
|
|
|
|
|
|
|
|
if (run_command(&cp))
|
|
|
|
fprintf(f, "(diff failed)\n");
|
|
|
|
|
|
|
|
done:
|
|
|
|
strbuf_release(&submodule_dir);
|
|
|
|
if (merge_bases)
|
|
|
|
free_commit_list(merge_bases);
|
|
|
|
if (left)
|
|
|
|
clear_commit_marks(left, ~0);
|
|
|
|
if (right)
|
|
|
|
clear_commit_marks(right, ~0);
|
|
|
|
}
|
|
|
|
|
2010-11-10 23:55:02 +00:00
|
|
|
void set_config_fetch_recurse_submodules(int value)
|
|
|
|
{
|
|
|
|
config_fetch_recurse_submodules = value;
|
|
|
|
}
|
|
|
|
|
2015-05-25 18:39:07 +00:00
|
|
|
static int has_remote(const char *refname, const struct object_id *oid,
|
|
|
|
int flags, void *cb_data)
|
2011-08-19 22:08:47 +00:00
|
|
|
{
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int submodule_needs_pushing(const char *path, const unsigned char sha1[20])
|
|
|
|
{
|
|
|
|
if (add_submodule_odb(path) || !lookup_commit_reference(sha1))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (for_each_remote_ref_submodule(path, has_remote, NULL) > 0) {
|
2014-08-19 19:09:35 +00:00
|
|
|
struct child_process cp = CHILD_PROCESS_INIT;
|
2011-08-19 22:08:47 +00:00
|
|
|
const char *argv[] = {"rev-list", NULL, "--not", "--remotes", "-n", "1" , NULL};
|
|
|
|
struct strbuf buf = STRBUF_INIT;
|
|
|
|
int needs_pushing = 0;
|
|
|
|
|
|
|
|
argv[1] = sha1_to_hex(sha1);
|
|
|
|
cp.argv = argv;
|
2016-04-28 13:39:15 +00:00
|
|
|
prepare_submodule_repo_env(&cp.env_array);
|
2011-08-19 22:08:47 +00:00
|
|
|
cp.git_cmd = 1;
|
|
|
|
cp.no_stdin = 1;
|
|
|
|
cp.out = -1;
|
|
|
|
cp.dir = path;
|
|
|
|
if (start_command(&cp))
|
|
|
|
die("Could not run 'git rev-list %s --not --remotes -n 1' command in submodule %s",
|
|
|
|
sha1_to_hex(sha1), path);
|
|
|
|
if (strbuf_read(&buf, cp.out, 41))
|
|
|
|
needs_pushing = 1;
|
|
|
|
finish_command(&cp);
|
|
|
|
close(cp.out);
|
|
|
|
strbuf_release(&buf);
|
|
|
|
return needs_pushing;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void collect_submodules_from_diff(struct diff_queue_struct *q,
|
|
|
|
struct diff_options *options,
|
|
|
|
void *data)
|
|
|
|
{
|
|
|
|
int i;
|
2012-03-29 07:21:23 +00:00
|
|
|
struct string_list *needs_pushing = data;
|
2011-08-19 22:08:47 +00:00
|
|
|
|
|
|
|
for (i = 0; i < q->nr; i++) {
|
|
|
|
struct diff_filepair *p = q->queue[i];
|
|
|
|
if (!S_ISGITLINK(p->two->mode))
|
|
|
|
continue;
|
2016-06-24 23:09:23 +00:00
|
|
|
if (submodule_needs_pushing(p->two->path, p->two->oid.hash))
|
2012-03-29 07:21:23 +00:00
|
|
|
string_list_insert(needs_pushing, p->two->path);
|
2011-08-19 22:08:47 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-03-29 07:21:23 +00:00
|
|
|
static void find_unpushed_submodule_commits(struct commit *commit,
|
|
|
|
struct string_list *needs_pushing)
|
2011-08-19 22:08:47 +00:00
|
|
|
{
|
|
|
|
struct rev_info rev;
|
|
|
|
|
|
|
|
init_revisions(&rev, NULL);
|
|
|
|
rev.diffopt.output_format |= DIFF_FORMAT_CALLBACK;
|
|
|
|
rev.diffopt.format_callback = collect_submodules_from_diff;
|
|
|
|
rev.diffopt.format_callback_data = needs_pushing;
|
2011-12-17 10:27:19 +00:00
|
|
|
diff_tree_combined_merge(commit, 1, &rev);
|
2011-08-19 22:08:47 +00:00
|
|
|
}
|
|
|
|
|
2012-03-29 07:21:23 +00:00
|
|
|
int find_unpushed_submodules(unsigned char new_sha1[20],
|
|
|
|
const char *remotes_name, struct string_list *needs_pushing)
|
2011-08-19 22:08:47 +00:00
|
|
|
{
|
|
|
|
struct rev_info rev;
|
|
|
|
struct commit *commit;
|
|
|
|
const char *argv[] = {NULL, NULL, "--not", "NULL", NULL};
|
|
|
|
int argc = ARRAY_SIZE(argv) - 1;
|
|
|
|
char *sha1_copy;
|
2012-03-29 07:21:23 +00:00
|
|
|
|
2011-08-19 22:08:47 +00:00
|
|
|
struct strbuf remotes_arg = STRBUF_INIT;
|
|
|
|
|
|
|
|
strbuf_addf(&remotes_arg, "--remotes=%s", remotes_name);
|
|
|
|
init_revisions(&rev, NULL);
|
|
|
|
sha1_copy = xstrdup(sha1_to_hex(new_sha1));
|
|
|
|
argv[1] = sha1_copy;
|
|
|
|
argv[3] = remotes_arg.buf;
|
|
|
|
setup_revisions(argc, argv, &rev, NULL);
|
|
|
|
if (prepare_revision_walk(&rev))
|
|
|
|
die("revision walk setup failed");
|
|
|
|
|
2012-03-29 07:21:23 +00:00
|
|
|
while ((commit = get_revision(&rev)) != NULL)
|
|
|
|
find_unpushed_submodule_commits(commit, needs_pushing);
|
2011-08-19 22:08:47 +00:00
|
|
|
|
2012-03-29 07:21:21 +00:00
|
|
|
reset_revision_walk();
|
2011-08-19 22:08:47 +00:00
|
|
|
free(sha1_copy);
|
|
|
|
strbuf_release(&remotes_arg);
|
|
|
|
|
2012-03-29 07:21:23 +00:00
|
|
|
return needs_pushing->nr;
|
2011-08-19 22:08:47 +00:00
|
|
|
}
|
|
|
|
|
2012-03-29 07:21:24 +00:00
|
|
|
static int push_submodule(const char *path)
|
|
|
|
{
|
|
|
|
if (add_submodule_odb(path))
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
if (for_each_remote_ref_submodule(path, has_remote, NULL) > 0) {
|
2014-08-19 19:09:35 +00:00
|
|
|
struct child_process cp = CHILD_PROCESS_INIT;
|
2012-03-29 07:21:24 +00:00
|
|
|
const char *argv[] = {"push", NULL};
|
|
|
|
|
|
|
|
cp.argv = argv;
|
2016-04-28 13:39:15 +00:00
|
|
|
prepare_submodule_repo_env(&cp.env_array);
|
2012-03-29 07:21:24 +00:00
|
|
|
cp.git_cmd = 1;
|
|
|
|
cp.no_stdin = 1;
|
|
|
|
cp.dir = path;
|
|
|
|
if (run_command(&cp))
|
|
|
|
return 0;
|
|
|
|
close(cp.out);
|
|
|
|
}
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
int push_unpushed_submodules(unsigned char new_sha1[20], const char *remotes_name)
|
|
|
|
{
|
|
|
|
int i, ret = 1;
|
2014-07-18 09:19:00 +00:00
|
|
|
struct string_list needs_pushing = STRING_LIST_INIT_DUP;
|
2012-03-29 07:21:24 +00:00
|
|
|
|
|
|
|
if (!find_unpushed_submodules(new_sha1, remotes_name, &needs_pushing))
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
for (i = 0; i < needs_pushing.nr; i++) {
|
|
|
|
const char *path = needs_pushing.items[i].string;
|
|
|
|
fprintf(stderr, "Pushing submodule '%s'\n", path);
|
|
|
|
if (!push_submodule(path)) {
|
|
|
|
fprintf(stderr, "Unable to push submodule '%s'\n", path);
|
|
|
|
ret = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
string_list_clear(&needs_pushing, 0);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2011-03-06 22:12:58 +00:00
|
|
|
static int is_submodule_commit_present(const char *path, unsigned char sha1[20])
|
|
|
|
{
|
|
|
|
int is_present = 0;
|
|
|
|
if (!add_submodule_odb(path) && lookup_commit_reference(sha1)) {
|
|
|
|
/* Even if the submodule is checked out and the commit is
|
|
|
|
* present, make sure it is reachable from a ref. */
|
2014-08-19 19:09:35 +00:00
|
|
|
struct child_process cp = CHILD_PROCESS_INIT;
|
2011-03-06 22:12:58 +00:00
|
|
|
const char *argv[] = {"rev-list", "-n", "1", NULL, "--not", "--all", NULL};
|
|
|
|
struct strbuf buf = STRBUF_INIT;
|
|
|
|
|
|
|
|
argv[3] = sha1_to_hex(sha1);
|
|
|
|
cp.argv = argv;
|
2016-04-28 13:39:15 +00:00
|
|
|
prepare_submodule_repo_env(&cp.env_array);
|
2011-03-06 22:12:58 +00:00
|
|
|
cp.git_cmd = 1;
|
|
|
|
cp.no_stdin = 1;
|
|
|
|
cp.dir = path;
|
2015-03-23 03:53:56 +00:00
|
|
|
if (!capture_command(&cp, &buf, 1024) && !buf.len)
|
2011-03-06 22:12:58 +00:00
|
|
|
is_present = 1;
|
|
|
|
|
|
|
|
strbuf_release(&buf);
|
|
|
|
}
|
|
|
|
return is_present;
|
|
|
|
}
|
|
|
|
|
2011-03-06 22:10:46 +00:00
|
|
|
static void submodule_collect_changed_cb(struct diff_queue_struct *q,
|
|
|
|
struct diff_options *options,
|
|
|
|
void *data)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
for (i = 0; i < q->nr; i++) {
|
|
|
|
struct diff_filepair *p = q->queue[i];
|
|
|
|
if (!S_ISGITLINK(p->two->mode))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (S_ISGITLINK(p->one->mode)) {
|
|
|
|
/* NEEDSWORK: We should honor the name configured in
|
|
|
|
* the .gitmodules file of the commit we are examining
|
|
|
|
* here to be able to correctly follow submodules
|
|
|
|
* being moved around. */
|
|
|
|
struct string_list_item *path;
|
|
|
|
path = unsorted_string_list_lookup(&changed_submodule_paths, p->two->path);
|
2016-06-24 23:09:23 +00:00
|
|
|
if (!path && !is_submodule_commit_present(p->two->path, p->two->oid.hash))
|
2011-03-06 22:10:46 +00:00
|
|
|
string_list_append(&changed_submodule_paths, xstrdup(p->two->path));
|
|
|
|
} else {
|
|
|
|
/* Submodule is new or was moved here */
|
|
|
|
/* NEEDSWORK: When the .git directories of submodules
|
|
|
|
* live inside the superprojects .git directory some
|
|
|
|
* day we should fetch new submodules directly into
|
|
|
|
* that location too when config or options request
|
|
|
|
* that so they can be checked out from there. */
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-05-25 18:39:07 +00:00
|
|
|
static int add_sha1_to_array(const char *ref, const struct object_id *oid,
|
2011-09-12 19:56:52 +00:00
|
|
|
int flags, void *data)
|
|
|
|
{
|
2015-05-25 18:39:07 +00:00
|
|
|
sha1_array_append(data, oid->hash);
|
2011-09-12 19:56:52 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-03-06 22:10:46 +00:00
|
|
|
void check_for_new_submodule_commits(unsigned char new_sha1[20])
|
2011-09-12 19:56:52 +00:00
|
|
|
{
|
|
|
|
if (!initialized_fetch_ref_tips) {
|
|
|
|
for_each_ref(add_sha1_to_array, &ref_tips_before_fetch);
|
|
|
|
initialized_fetch_ref_tips = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
sha1_array_append(&ref_tips_after_fetch, new_sha1);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void add_sha1_to_argv(const unsigned char sha1[20], void *data)
|
|
|
|
{
|
2011-09-13 21:57:57 +00:00
|
|
|
argv_array_push(data, sha1_to_hex(sha1));
|
2011-09-12 19:56:52 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void calculate_changed_submodule_paths(void)
|
2011-03-06 22:10:46 +00:00
|
|
|
{
|
|
|
|
struct rev_info rev;
|
|
|
|
struct commit *commit;
|
2011-09-13 21:57:57 +00:00
|
|
|
struct argv_array argv = ARGV_ARRAY_INIT;
|
2011-03-06 22:10:46 +00:00
|
|
|
|
2011-09-09 18:22:03 +00:00
|
|
|
/* No need to check if there are no submodules configured */
|
2015-08-18 00:21:59 +00:00
|
|
|
if (!submodule_from_path(NULL, NULL))
|
2011-09-09 18:22:03 +00:00
|
|
|
return;
|
|
|
|
|
2011-03-06 22:10:46 +00:00
|
|
|
init_revisions(&rev, NULL);
|
2011-09-13 21:57:57 +00:00
|
|
|
argv_array_push(&argv, "--"); /* argv[0] program name */
|
2011-09-12 19:56:52 +00:00
|
|
|
sha1_array_for_each_unique(&ref_tips_after_fetch,
|
|
|
|
add_sha1_to_argv, &argv);
|
2011-09-13 21:57:57 +00:00
|
|
|
argv_array_push(&argv, "--not");
|
2011-09-12 19:56:52 +00:00
|
|
|
sha1_array_for_each_unique(&ref_tips_before_fetch,
|
|
|
|
add_sha1_to_argv, &argv);
|
|
|
|
setup_revisions(argv.argc, argv.argv, &rev, NULL);
|
2011-03-06 22:10:46 +00:00
|
|
|
if (prepare_revision_walk(&rev))
|
|
|
|
die("revision walk setup failed");
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Collect all submodules (whether checked out or not) for which new
|
|
|
|
* commits have been recorded upstream in "changed_submodule_paths".
|
|
|
|
*/
|
|
|
|
while ((commit = get_revision(&rev))) {
|
|
|
|
struct commit_list *parent = commit->parents;
|
|
|
|
while (parent) {
|
|
|
|
struct diff_options diff_opts;
|
|
|
|
diff_setup(&diff_opts);
|
2011-06-20 18:18:03 +00:00
|
|
|
DIFF_OPT_SET(&diff_opts, RECURSIVE);
|
2011-03-06 22:10:46 +00:00
|
|
|
diff_opts.output_format |= DIFF_FORMAT_CALLBACK;
|
|
|
|
diff_opts.format_callback = submodule_collect_changed_cb;
|
2012-08-03 12:16:24 +00:00
|
|
|
diff_setup_done(&diff_opts);
|
2015-11-10 02:22:29 +00:00
|
|
|
diff_tree_sha1(parent->item->object.oid.hash, commit->object.oid.hash, "", &diff_opts);
|
2011-03-06 22:10:46 +00:00
|
|
|
diffcore_std(&diff_opts);
|
|
|
|
diff_flush(&diff_opts);
|
|
|
|
parent = parent->next;
|
|
|
|
}
|
|
|
|
}
|
2011-09-12 19:56:52 +00:00
|
|
|
|
2011-09-13 21:57:57 +00:00
|
|
|
argv_array_clear(&argv);
|
2011-09-12 19:56:52 +00:00
|
|
|
sha1_array_clear(&ref_tips_before_fetch);
|
|
|
|
sha1_array_clear(&ref_tips_after_fetch);
|
|
|
|
initialized_fetch_ref_tips = 0;
|
2011-03-06 22:10:46 +00:00
|
|
|
}
|
|
|
|
|
2015-12-16 00:04:11 +00:00
|
|
|
struct submodule_parallel_fetch {
|
|
|
|
int count;
|
|
|
|
struct argv_array args;
|
|
|
|
const char *work_tree;
|
|
|
|
const char *prefix;
|
|
|
|
int command_line_option;
|
|
|
|
int quiet;
|
|
|
|
int result;
|
|
|
|
};
|
|
|
|
#define SPF_INIT {0, ARGV_ARRAY_INIT, NULL, NULL, 0, 0, 0}
|
|
|
|
|
|
|
|
static int get_next_submodule(struct child_process *cp,
|
|
|
|
struct strbuf *err, void *data, void **task_cb)
|
2010-11-12 12:54:52 +00:00
|
|
|
{
|
2015-12-16 00:04:11 +00:00
|
|
|
int ret = 0;
|
|
|
|
struct submodule_parallel_fetch *spf = data;
|
2011-09-12 19:56:52 +00:00
|
|
|
|
2015-12-16 00:04:11 +00:00
|
|
|
for (; spf->count < active_nr; spf->count++) {
|
2010-11-12 12:54:52 +00:00
|
|
|
struct strbuf submodule_path = STRBUF_INIT;
|
|
|
|
struct strbuf submodule_git_dir = STRBUF_INIT;
|
|
|
|
struct strbuf submodule_prefix = STRBUF_INIT;
|
2015-12-16 00:04:11 +00:00
|
|
|
const struct cache_entry *ce = active_cache[spf->count];
|
2015-08-18 00:21:59 +00:00
|
|
|
const char *git_dir, *default_argv;
|
|
|
|
const struct submodule *submodule;
|
2010-11-12 12:54:52 +00:00
|
|
|
|
|
|
|
if (!S_ISGITLINK(ce->ce_mode))
|
|
|
|
continue;
|
|
|
|
|
2015-08-18 00:21:59 +00:00
|
|
|
submodule = submodule_from_path(null_sha1, ce->name);
|
|
|
|
if (!submodule)
|
|
|
|
submodule = submodule_from_name(null_sha1, ce->name);
|
2010-11-12 12:54:52 +00:00
|
|
|
|
2011-03-06 22:10:46 +00:00
|
|
|
default_argv = "yes";
|
2015-12-16 00:04:11 +00:00
|
|
|
if (spf->command_line_option == RECURSE_SUBMODULES_DEFAULT) {
|
2015-08-18 00:21:59 +00:00
|
|
|
if (submodule &&
|
|
|
|
submodule->fetch_recurse !=
|
|
|
|
RECURSE_SUBMODULES_NONE) {
|
|
|
|
if (submodule->fetch_recurse ==
|
|
|
|
RECURSE_SUBMODULES_OFF)
|
2010-11-10 23:55:41 +00:00
|
|
|
continue;
|
2015-08-18 00:21:59 +00:00
|
|
|
if (submodule->fetch_recurse ==
|
|
|
|
RECURSE_SUBMODULES_ON_DEMAND) {
|
2011-03-06 22:12:19 +00:00
|
|
|
if (!unsorted_string_list_lookup(&changed_submodule_paths, ce->name))
|
|
|
|
continue;
|
|
|
|
default_argv = "on-demand";
|
|
|
|
}
|
2010-11-10 23:55:41 +00:00
|
|
|
} else {
|
2011-05-14 16:26:58 +00:00
|
|
|
if ((config_fetch_recurse_submodules == RECURSE_SUBMODULES_OFF) ||
|
|
|
|
gitmodules_is_unmerged)
|
2010-11-10 23:55:41 +00:00
|
|
|
continue;
|
2011-03-06 22:10:46 +00:00
|
|
|
if (config_fetch_recurse_submodules == RECURSE_SUBMODULES_ON_DEMAND) {
|
|
|
|
if (!unsorted_string_list_lookup(&changed_submodule_paths, ce->name))
|
|
|
|
continue;
|
|
|
|
default_argv = "on-demand";
|
|
|
|
}
|
2010-11-10 23:55:41 +00:00
|
|
|
}
|
2015-12-16 00:04:11 +00:00
|
|
|
} else if (spf->command_line_option == RECURSE_SUBMODULES_ON_DEMAND) {
|
2011-03-06 22:11:21 +00:00
|
|
|
if (!unsorted_string_list_lookup(&changed_submodule_paths, ce->name))
|
|
|
|
continue;
|
|
|
|
default_argv = "on-demand";
|
2010-11-10 23:55:02 +00:00
|
|
|
}
|
|
|
|
|
2015-12-16 00:04:11 +00:00
|
|
|
strbuf_addf(&submodule_path, "%s/%s", spf->work_tree, ce->name);
|
2010-11-12 12:54:52 +00:00
|
|
|
strbuf_addf(&submodule_git_dir, "%s/.git", submodule_path.buf);
|
2015-12-16 00:04:11 +00:00
|
|
|
strbuf_addf(&submodule_prefix, "%s%s/", spf->prefix, ce->name);
|
2011-08-22 21:04:56 +00:00
|
|
|
git_dir = read_gitfile(submodule_git_dir.buf);
|
2010-11-12 12:54:52 +00:00
|
|
|
if (!git_dir)
|
|
|
|
git_dir = submodule_git_dir.buf;
|
|
|
|
if (is_directory(git_dir)) {
|
2015-12-16 00:04:11 +00:00
|
|
|
child_process_init(cp);
|
|
|
|
cp->dir = strbuf_detach(&submodule_path, NULL);
|
2016-04-28 13:39:15 +00:00
|
|
|
prepare_submodule_repo_env(&cp->env_array);
|
2015-12-16 00:04:11 +00:00
|
|
|
cp->git_cmd = 1;
|
|
|
|
if (!spf->quiet)
|
|
|
|
strbuf_addf(err, "Fetching submodule %s%s\n",
|
|
|
|
spf->prefix, ce->name);
|
|
|
|
argv_array_init(&cp->args);
|
|
|
|
argv_array_pushv(&cp->args, spf->args.argv);
|
|
|
|
argv_array_push(&cp->args, default_argv);
|
|
|
|
argv_array_push(&cp->args, "--submodule-prefix");
|
|
|
|
argv_array_push(&cp->args, submodule_prefix.buf);
|
|
|
|
ret = 1;
|
2010-11-12 12:54:52 +00:00
|
|
|
}
|
|
|
|
strbuf_release(&submodule_path);
|
|
|
|
strbuf_release(&submodule_git_dir);
|
|
|
|
strbuf_release(&submodule_prefix);
|
2015-12-16 00:04:11 +00:00
|
|
|
if (ret) {
|
|
|
|
spf->count++;
|
|
|
|
return 1;
|
|
|
|
}
|
2010-11-12 12:54:52 +00:00
|
|
|
}
|
2015-12-16 00:04:11 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2016-02-29 21:57:06 +00:00
|
|
|
static int fetch_start_failure(struct strbuf *err,
|
2015-12-16 00:04:11 +00:00
|
|
|
void *cb, void *task_cb)
|
|
|
|
{
|
|
|
|
struct submodule_parallel_fetch *spf = cb;
|
|
|
|
|
|
|
|
spf->result = 1;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2016-02-29 21:57:06 +00:00
|
|
|
static int fetch_finish(int retvalue, struct strbuf *err,
|
|
|
|
void *cb, void *task_cb)
|
2015-12-16 00:04:11 +00:00
|
|
|
{
|
|
|
|
struct submodule_parallel_fetch *spf = cb;
|
|
|
|
|
|
|
|
if (retvalue)
|
|
|
|
spf->result = 1;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int fetch_populated_submodules(const struct argv_array *options,
|
|
|
|
const char *prefix, int command_line_option,
|
2015-12-16 00:04:12 +00:00
|
|
|
int quiet, int max_parallel_jobs)
|
2015-12-16 00:04:11 +00:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
struct submodule_parallel_fetch spf = SPF_INIT;
|
|
|
|
|
|
|
|
spf.work_tree = get_git_work_tree();
|
|
|
|
spf.command_line_option = command_line_option;
|
|
|
|
spf.quiet = quiet;
|
|
|
|
spf.prefix = prefix;
|
|
|
|
|
|
|
|
if (!spf.work_tree)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
if (read_cache() < 0)
|
|
|
|
die("index file corrupt");
|
|
|
|
|
|
|
|
argv_array_push(&spf.args, "fetch");
|
|
|
|
for (i = 0; i < options->argc; i++)
|
|
|
|
argv_array_push(&spf.args, options->argv[i]);
|
|
|
|
argv_array_push(&spf.args, "--recurse-submodules-default");
|
|
|
|
/* default value, "--submodule-prefix" and its value are added later */
|
|
|
|
|
2016-03-01 02:07:13 +00:00
|
|
|
if (max_parallel_jobs < 0)
|
|
|
|
max_parallel_jobs = parallel_jobs;
|
|
|
|
|
2015-12-16 00:04:11 +00:00
|
|
|
calculate_changed_submodule_paths();
|
|
|
|
run_processes_parallel(max_parallel_jobs,
|
|
|
|
get_next_submodule,
|
|
|
|
fetch_start_failure,
|
|
|
|
fetch_finish,
|
|
|
|
&spf);
|
|
|
|
|
|
|
|
argv_array_clear(&spf.args);
|
2011-03-06 22:10:46 +00:00
|
|
|
out:
|
|
|
|
string_list_clear(&changed_submodule_paths, 1);
|
2015-12-16 00:04:11 +00:00
|
|
|
return spf.result;
|
2010-11-12 12:54:52 +00:00
|
|
|
}
|
|
|
|
|
2010-03-13 22:00:27 +00:00
|
|
|
unsigned is_submodule_modified(const char *path, int ignore_untracked)
|
2010-01-16 17:42:24 +00:00
|
|
|
{
|
2010-03-04 21:20:33 +00:00
|
|
|
ssize_t len;
|
2014-08-19 19:09:35 +00:00
|
|
|
struct child_process cp = CHILD_PROCESS_INIT;
|
2010-01-16 17:42:24 +00:00
|
|
|
const char *argv[] = {
|
|
|
|
"status",
|
|
|
|
"--porcelain",
|
|
|
|
NULL,
|
2010-03-13 22:00:27 +00:00
|
|
|
NULL,
|
2010-01-16 17:42:24 +00:00
|
|
|
};
|
|
|
|
struct strbuf buf = STRBUF_INIT;
|
2010-03-04 21:20:33 +00:00
|
|
|
unsigned dirty_submodule = 0;
|
|
|
|
const char *line, *next_line;
|
2010-04-10 17:01:12 +00:00
|
|
|
const char *git_dir;
|
2010-01-16 17:42:24 +00:00
|
|
|
|
2010-04-10 17:01:12 +00:00
|
|
|
strbuf_addf(&buf, "%s/.git", path);
|
2011-08-22 21:04:56 +00:00
|
|
|
git_dir = read_gitfile(buf.buf);
|
2010-04-10 17:01:12 +00:00
|
|
|
if (!git_dir)
|
|
|
|
git_dir = buf.buf;
|
|
|
|
if (!is_directory(git_dir)) {
|
2010-01-16 17:42:24 +00:00
|
|
|
strbuf_release(&buf);
|
|
|
|
/* The submodule is not checked out, so it is not modified */
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
}
|
|
|
|
strbuf_reset(&buf);
|
|
|
|
|
2010-03-13 22:00:27 +00:00
|
|
|
if (ignore_untracked)
|
|
|
|
argv[2] = "-uno";
|
|
|
|
|
2010-01-16 17:42:24 +00:00
|
|
|
cp.argv = argv;
|
2016-04-28 13:39:15 +00:00
|
|
|
prepare_submodule_repo_env(&cp.env_array);
|
2010-01-16 17:42:24 +00:00
|
|
|
cp.git_cmd = 1;
|
|
|
|
cp.no_stdin = 1;
|
|
|
|
cp.out = -1;
|
2010-04-10 17:01:12 +00:00
|
|
|
cp.dir = path;
|
2010-01-16 17:42:24 +00:00
|
|
|
if (start_command(&cp))
|
2011-12-07 21:50:14 +00:00
|
|
|
die("Could not run 'git status --porcelain' in submodule %s", path);
|
2010-01-16 17:42:24 +00:00
|
|
|
|
|
|
|
len = strbuf_read(&buf, cp.out, 1024);
|
2010-03-04 21:20:33 +00:00
|
|
|
line = buf.buf;
|
|
|
|
while (len > 2) {
|
|
|
|
if ((line[0] == '?') && (line[1] == '?')) {
|
|
|
|
dirty_submodule |= DIRTY_SUBMODULE_UNTRACKED;
|
|
|
|
if (dirty_submodule & DIRTY_SUBMODULE_MODIFIED)
|
|
|
|
break;
|
|
|
|
} else {
|
|
|
|
dirty_submodule |= DIRTY_SUBMODULE_MODIFIED;
|
2010-03-13 22:00:27 +00:00
|
|
|
if (ignore_untracked ||
|
|
|
|
(dirty_submodule & DIRTY_SUBMODULE_UNTRACKED))
|
2010-03-04 21:20:33 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
next_line = strchr(line, '\n');
|
|
|
|
if (!next_line)
|
|
|
|
break;
|
|
|
|
next_line++;
|
|
|
|
len -= (next_line - line);
|
|
|
|
line = next_line;
|
|
|
|
}
|
2010-01-16 17:42:24 +00:00
|
|
|
close(cp.out);
|
|
|
|
|
|
|
|
if (finish_command(&cp))
|
2011-12-07 21:50:14 +00:00
|
|
|
die("'git status --porcelain' failed in submodule %s", path);
|
2010-01-16 17:42:24 +00:00
|
|
|
|
|
|
|
strbuf_release(&buf);
|
2010-03-04 21:20:33 +00:00
|
|
|
return dirty_submodule;
|
2010-01-16 17:42:24 +00:00
|
|
|
}
|
2010-07-07 13:39:13 +00:00
|
|
|
|
2012-09-26 18:21:13 +00:00
|
|
|
int submodule_uses_gitfile(const char *path)
|
|
|
|
{
|
2014-08-19 19:09:35 +00:00
|
|
|
struct child_process cp = CHILD_PROCESS_INIT;
|
2012-09-26 18:21:13 +00:00
|
|
|
const char *argv[] = {
|
|
|
|
"submodule",
|
|
|
|
"foreach",
|
|
|
|
"--quiet",
|
|
|
|
"--recursive",
|
|
|
|
"test -f .git",
|
|
|
|
NULL,
|
|
|
|
};
|
|
|
|
struct strbuf buf = STRBUF_INIT;
|
|
|
|
const char *git_dir;
|
|
|
|
|
|
|
|
strbuf_addf(&buf, "%s/.git", path);
|
|
|
|
git_dir = read_gitfile(buf.buf);
|
|
|
|
if (!git_dir) {
|
|
|
|
strbuf_release(&buf);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
strbuf_release(&buf);
|
|
|
|
|
|
|
|
/* Now test that all nested submodules use a gitfile too */
|
|
|
|
cp.argv = argv;
|
2016-04-28 13:39:15 +00:00
|
|
|
prepare_submodule_repo_env(&cp.env_array);
|
2012-09-26 18:21:13 +00:00
|
|
|
cp.git_cmd = 1;
|
|
|
|
cp.no_stdin = 1;
|
|
|
|
cp.no_stderr = 1;
|
|
|
|
cp.no_stdout = 1;
|
|
|
|
cp.dir = path;
|
|
|
|
if (run_command(&cp))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
int ok_to_remove_submodule(const char *path)
|
|
|
|
{
|
|
|
|
ssize_t len;
|
2014-08-19 19:09:35 +00:00
|
|
|
struct child_process cp = CHILD_PROCESS_INIT;
|
2012-09-26 18:21:13 +00:00
|
|
|
const char *argv[] = {
|
|
|
|
"status",
|
|
|
|
"--porcelain",
|
|
|
|
"-u",
|
|
|
|
"--ignore-submodules=none",
|
|
|
|
NULL,
|
|
|
|
};
|
|
|
|
struct strbuf buf = STRBUF_INIT;
|
|
|
|
int ok_to_remove = 1;
|
|
|
|
|
2015-05-19 21:44:23 +00:00
|
|
|
if (!file_exists(path) || is_empty_dir(path))
|
2012-09-26 18:21:13 +00:00
|
|
|
return 1;
|
|
|
|
|
|
|
|
if (!submodule_uses_gitfile(path))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
cp.argv = argv;
|
2016-04-28 13:39:15 +00:00
|
|
|
prepare_submodule_repo_env(&cp.env_array);
|
2012-09-26 18:21:13 +00:00
|
|
|
cp.git_cmd = 1;
|
|
|
|
cp.no_stdin = 1;
|
|
|
|
cp.out = -1;
|
|
|
|
cp.dir = path;
|
|
|
|
if (start_command(&cp))
|
|
|
|
die("Could not run 'git status --porcelain -uall --ignore-submodules=none' in submodule %s", path);
|
|
|
|
|
|
|
|
len = strbuf_read(&buf, cp.out, 1024);
|
|
|
|
if (len > 2)
|
|
|
|
ok_to_remove = 0;
|
|
|
|
close(cp.out);
|
|
|
|
|
|
|
|
if (finish_command(&cp))
|
|
|
|
die("'git status --porcelain -uall --ignore-submodules=none' failed in submodule %s", path);
|
|
|
|
|
|
|
|
strbuf_release(&buf);
|
|
|
|
return ok_to_remove;
|
|
|
|
}
|
|
|
|
|
2010-07-07 13:39:13 +00:00
|
|
|
static int find_first_merges(struct object_array *result, const char *path,
|
|
|
|
struct commit *a, struct commit *b)
|
|
|
|
{
|
|
|
|
int i, j;
|
2013-05-25 09:08:12 +00:00
|
|
|
struct object_array merges = OBJECT_ARRAY_INIT;
|
2010-07-07 13:39:13 +00:00
|
|
|
struct commit *commit;
|
|
|
|
int contains_another;
|
|
|
|
|
|
|
|
char merged_revision[42];
|
|
|
|
const char *rev_args[] = { "rev-list", "--merges", "--ancestry-path",
|
|
|
|
"--all", merged_revision, NULL };
|
|
|
|
struct rev_info revs;
|
|
|
|
struct setup_revision_opt rev_opts;
|
|
|
|
|
|
|
|
memset(result, 0, sizeof(struct object_array));
|
|
|
|
memset(&rev_opts, 0, sizeof(rev_opts));
|
|
|
|
|
|
|
|
/* get all revisions that merge commit a */
|
|
|
|
snprintf(merged_revision, sizeof(merged_revision), "^%s",
|
2015-11-10 02:22:28 +00:00
|
|
|
oid_to_hex(&a->object.oid));
|
2010-07-07 13:39:13 +00:00
|
|
|
init_revisions(&revs, NULL);
|
|
|
|
rev_opts.submodule = path;
|
2014-06-27 12:11:39 +00:00
|
|
|
setup_revisions(ARRAY_SIZE(rev_args)-1, rev_args, &revs, &rev_opts);
|
2010-07-07 13:39:13 +00:00
|
|
|
|
|
|
|
/* save all revisions from the above list that contain b */
|
|
|
|
if (prepare_revision_walk(&revs))
|
|
|
|
die("revision walk setup failed");
|
|
|
|
while ((commit = get_revision(&revs)) != NULL) {
|
|
|
|
struct object *o = &(commit->object);
|
2012-08-27 21:46:01 +00:00
|
|
|
if (in_merge_bases(b, commit))
|
2010-07-07 13:39:13 +00:00
|
|
|
add_object_array(o, NULL, &merges);
|
|
|
|
}
|
2012-03-29 07:21:21 +00:00
|
|
|
reset_revision_walk();
|
2010-07-07 13:39:13 +00:00
|
|
|
|
|
|
|
/* Now we've got all merges that contain a and b. Prune all
|
|
|
|
* merges that contain another found merge and save them in
|
|
|
|
* result.
|
|
|
|
*/
|
|
|
|
for (i = 0; i < merges.nr; i++) {
|
|
|
|
struct commit *m1 = (struct commit *) merges.objects[i].item;
|
|
|
|
|
|
|
|
contains_another = 0;
|
|
|
|
for (j = 0; j < merges.nr; j++) {
|
|
|
|
struct commit *m2 = (struct commit *) merges.objects[j].item;
|
2012-08-27 21:46:01 +00:00
|
|
|
if (i != j && in_merge_bases(m2, m1)) {
|
2010-07-07 13:39:13 +00:00
|
|
|
contains_another = 1;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!contains_another)
|
2013-05-25 09:08:13 +00:00
|
|
|
add_object_array(merges.objects[i].item, NULL, result);
|
2010-07-07 13:39:13 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
free(merges.objects);
|
|
|
|
return result->nr;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void print_commit(struct commit *commit)
|
|
|
|
{
|
|
|
|
struct strbuf sb = STRBUF_INIT;
|
|
|
|
struct pretty_print_context ctx = {0};
|
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
|
|
|
ctx.date_mode.type = DATE_NORMAL;
|
2010-07-07 13:39:13 +00:00
|
|
|
format_commit_message(commit, " %h: %m %s", &sb, &ctx);
|
|
|
|
fprintf(stderr, "%s\n", sb.buf);
|
|
|
|
strbuf_release(&sb);
|
|
|
|
}
|
|
|
|
|
|
|
|
#define MERGE_WARNING(path, msg) \
|
|
|
|
warning("Failed to merge submodule %s (%s)", path, msg);
|
|
|
|
|
|
|
|
int merge_submodule(unsigned char result[20], const char *path,
|
|
|
|
const unsigned char base[20], const unsigned char a[20],
|
2011-10-13 12:59:05 +00:00
|
|
|
const unsigned char b[20], int search)
|
2010-07-07 13:39:13 +00:00
|
|
|
{
|
|
|
|
struct commit *commit_base, *commit_a, *commit_b;
|
|
|
|
int parent_count;
|
|
|
|
struct object_array merges;
|
|
|
|
|
|
|
|
int i;
|
|
|
|
|
|
|
|
/* store a in result in case we fail */
|
|
|
|
hashcpy(result, a);
|
|
|
|
|
|
|
|
/* we can not handle deletion conflicts */
|
|
|
|
if (is_null_sha1(base))
|
|
|
|
return 0;
|
|
|
|
if (is_null_sha1(a))
|
|
|
|
return 0;
|
|
|
|
if (is_null_sha1(b))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (add_submodule_odb(path)) {
|
|
|
|
MERGE_WARNING(path, "not checked out");
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!(commit_base = lookup_commit_reference(base)) ||
|
|
|
|
!(commit_a = lookup_commit_reference(a)) ||
|
|
|
|
!(commit_b = lookup_commit_reference(b))) {
|
|
|
|
MERGE_WARNING(path, "commits not present");
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* check whether both changes are forward */
|
2012-08-27 21:46:01 +00:00
|
|
|
if (!in_merge_bases(commit_base, commit_a) ||
|
|
|
|
!in_merge_bases(commit_base, commit_b)) {
|
2010-07-07 13:39:13 +00:00
|
|
|
MERGE_WARNING(path, "commits don't follow merge-base");
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Case #1: a is contained in b or vice versa */
|
2012-08-27 21:46:01 +00:00
|
|
|
if (in_merge_bases(commit_a, commit_b)) {
|
2010-07-07 13:39:13 +00:00
|
|
|
hashcpy(result, b);
|
|
|
|
return 1;
|
|
|
|
}
|
2012-08-27 21:46:01 +00:00
|
|
|
if (in_merge_bases(commit_b, commit_a)) {
|
2010-07-07 13:39:13 +00:00
|
|
|
hashcpy(result, a);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Case #2: There are one or more merges that contain a and b in
|
|
|
|
* the submodule. If there is only one, then present it as a
|
|
|
|
* suggestion to the user, but leave it marked unmerged so the
|
|
|
|
* user needs to confirm the resolution.
|
|
|
|
*/
|
|
|
|
|
2011-10-13 12:59:05 +00:00
|
|
|
/* Skip the search if makes no sense to the calling context. */
|
|
|
|
if (!search)
|
|
|
|
return 0;
|
|
|
|
|
2010-07-07 13:39:13 +00:00
|
|
|
/* find commit which merges them */
|
|
|
|
parent_count = find_first_merges(&merges, path, commit_a, commit_b);
|
|
|
|
switch (parent_count) {
|
|
|
|
case 0:
|
|
|
|
MERGE_WARNING(path, "merge following commits not found");
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 1:
|
|
|
|
MERGE_WARNING(path, "not fast-forward");
|
|
|
|
fprintf(stderr, "Found a possible merge resolution "
|
|
|
|
"for the submodule:\n");
|
|
|
|
print_commit((struct commit *) merges.objects[0].item);
|
|
|
|
fprintf(stderr,
|
|
|
|
"If this is correct simply add it to the index "
|
|
|
|
"for example\n"
|
|
|
|
"by using:\n\n"
|
|
|
|
" git update-index --cacheinfo 160000 %s \"%s\"\n\n"
|
|
|
|
"which will accept this suggestion.\n",
|
2015-11-10 02:22:28 +00:00
|
|
|
oid_to_hex(&merges.objects[0].item->oid), path);
|
2010-07-07 13:39:13 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
MERGE_WARNING(path, "multiple merges found");
|
|
|
|
for (i = 0; i < merges.nr; i++)
|
|
|
|
print_commit((struct commit *) merges.objects[i].item);
|
|
|
|
}
|
|
|
|
|
|
|
|
free(merges.objects);
|
|
|
|
return 0;
|
|
|
|
}
|
2013-07-30 19:50:03 +00:00
|
|
|
|
|
|
|
/* Update gitfile and core.worktree setting to connect work tree and git dir */
|
|
|
|
void connect_work_tree_and_git_dir(const char *work_tree, const char *git_dir)
|
|
|
|
{
|
|
|
|
struct strbuf file_name = STRBUF_INIT;
|
|
|
|
struct strbuf rel_path = STRBUF_INIT;
|
|
|
|
const char *real_work_tree = xstrdup(real_path(work_tree));
|
|
|
|
|
|
|
|
/* Update gitfile */
|
|
|
|
strbuf_addf(&file_name, "%s/.git", work_tree);
|
2015-08-24 20:20:39 +00:00
|
|
|
write_file(file_name.buf, "gitdir: %s",
|
2014-11-30 08:24:46 +00:00
|
|
|
relative_path(git_dir, real_work_tree, &rel_path));
|
2013-07-30 19:50:03 +00:00
|
|
|
|
|
|
|
/* Update core.worktree setting */
|
|
|
|
strbuf_reset(&file_name);
|
|
|
|
strbuf_addf(&file_name, "%s/config", git_dir);
|
2016-02-22 11:23:36 +00:00
|
|
|
git_config_set_in_file(file_name.buf, "core.worktree",
|
|
|
|
relative_path(real_work_tree, git_dir,
|
|
|
|
&rel_path));
|
2013-07-30 19:50:03 +00:00
|
|
|
|
|
|
|
strbuf_release(&file_name);
|
|
|
|
strbuf_release(&rel_path);
|
|
|
|
free((void *)real_work_tree);
|
|
|
|
}
|
2016-03-01 02:07:13 +00:00
|
|
|
|
|
|
|
int parallel_submodules(void)
|
|
|
|
{
|
|
|
|
return parallel_jobs;
|
|
|
|
}
|
2016-05-17 21:38:25 +00:00
|
|
|
|
2016-04-28 13:38:20 +00:00
|
|
|
void prepare_submodule_repo_env(struct argv_array *out)
|
|
|
|
{
|
|
|
|
const char * const *var;
|
|
|
|
|
|
|
|
for (var = local_repo_env; *var; var++) {
|
submodule: stop sanitizing config options
The point of having a whitelist of command-line config
options to pass to submodules was two-fold:
1. It prevented obvious nonsense like using core.worktree
for multiple repos.
2. It could prevent surprise when the user did not mean
for the options to leak to the submodules (e.g.,
http.sslverify=false).
For case 1, the answer is mostly "if it hurts, don't do
that". For case 2, we can note that any such example has a
matching inverted surprise (e.g., a user who meant
http.sslverify=true to apply everywhere, but it didn't).
So this whitelist is probably not giving us any benefit, and
is already creating a hassle as people propose things to put
on it. Let's just drop it entirely.
Note that we still need to keep a special code path for
"prepare the submodule environment", because we still have
to take care to pass through $GIT_CONFIG_PARAMETERS (and
block the rest of the repo-specific environment variables).
We can do this easily from within the submodule shell
script, which lets us drop the submodule--helper option
entirely (and it's OK to do so because as a "--" program, it
is entirely a private implementation detail).
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-05-05 01:22:19 +00:00
|
|
|
if (strcmp(*var, CONFIG_DATA_ENVIRONMENT))
|
2016-04-28 13:38:20 +00:00
|
|
|
argv_array_push(out, *var);
|
|
|
|
}
|
submodule: avoid auto-discovery in prepare_submodule_repo_env()
The function is used to set up the environment variable used in a
subprocess we spawn in a submodule directory. The callers set up a
child_process structure, find the working tree path of one submodule
and set .dir field to it, and then use start_command() API to spawn
the subprocess like "status", "fetch", etc.
When this happens, we expect that the ".git" (either a directory or
a gitfile that points at the real location) in the current working
directory of the subprocess MUST be the repository for the submodule.
If this ".git" thing is a corrupt repository, however, because
prepare_submodule_repo_env() unsets GIT_DIR and GIT_WORK_TREE, the
subprocess will see ".git", thinks it is not a repository, and
attempt to find one by going up, likely to end up in finding the
repository of the superproject. In some codepaths, this will cause
a command run with the "--recurse-submodules" option to recurse
forever.
By exporting GIT_DIR=.git, disable the auto-discovery logic in the
subprocess, which would instead stop it and report an error.
The test illustrates existing problems in a few callsites of this
function. Without this fix, "git fetch --recurse-submodules", "git
status" and "git diff" keep recursing forever.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-09-01 20:51:48 +00:00
|
|
|
argv_array_push(out, "GIT_DIR=.git");
|
2016-04-28 13:38:20 +00:00
|
|
|
}
|