submodule.c 8.97 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
/*
 * Copyright (C) 2012 the libgit2 contributors
 *
 * This file is part of libgit2, distributed under the GNU GPL v2 with
 * a Linking Exception. For full terms see the included COPYING file.
 */

#include "common.h"
#include "git2/config.h"
#include "git2/types.h"
#include "git2/repository.h"
#include "git2/index.h"
#include "git2/submodule.h"
#include "buffer.h"
#include "vector.h"
#include "posix.h"
#include "config_file.h"
#include "config.h"
#include "repository.h"

21 22 23 24
static git_cvar_map _sm_update_map[] = {
	{GIT_CVAR_STRING, "checkout", GIT_SUBMODULE_UPDATE_CHECKOUT},
	{GIT_CVAR_STRING, "rebase", GIT_SUBMODULE_UPDATE_REBASE},
	{GIT_CVAR_STRING, "merge", GIT_SUBMODULE_UPDATE_MERGE}
25 26
};

27 28 29 30 31
static git_cvar_map _sm_ignore_map[] = {
	{GIT_CVAR_STRING, "all", GIT_SUBMODULE_IGNORE_ALL},
	{GIT_CVAR_STRING, "dirty", GIT_SUBMODULE_IGNORE_DIRTY},
	{GIT_CVAR_STRING, "untracked", GIT_SUBMODULE_IGNORE_UNTRACKED},
	{GIT_CVAR_STRING, "none", GIT_SUBMODULE_IGNORE_NONE}
32 33
};

34
static inline khint_t str_hash_no_trailing_slash(const char *s)
35
{
36
	khint_t h;
37

38 39 40
	for (h = 0; *s; ++s)
		if (s[1] || *s != '/')
			h = (h << 5) - h + *s;
41

42
	return h;
43 44
}

45
static inline int str_equal_no_trailing_slash(const char *a, const char *b)
46
{
47 48
	size_t alen = a ? strlen(a) : 0;
	size_t blen = b ? strlen(b) : 0;
49

50
	if (alen && a[alen] == '/')
51
		alen--;
52
	if (blen && b[blen] == '/')
53 54
		blen--;

55
	return (alen == blen && strncmp(a, b, alen) == 0);
56 57
}

58 59
__KHASH_IMPL(str, static inline, const char *, void *, 1, str_hash_no_trailing_slash, str_equal_no_trailing_slash);

60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91
static git_submodule *submodule_alloc(const char *name)
{
	git_submodule *sm = git__calloc(1, sizeof(git_submodule));
	if (sm == NULL)
		return sm;

	sm->path = sm->name = git__strdup(name);
	if (!sm->name) {
		git__free(sm);
		return NULL;
	}

	return sm;
}

static void submodule_release(git_submodule *sm, int decr)
{
	if (!sm)
		return;

	sm->refcount -= decr;

	if (sm->refcount == 0) {
		if (sm->name != sm->path)
			git__free(sm->path);
		git__free(sm->name);
		git__free(sm->url);
		git__free(sm);
	}
}

static int submodule_from_entry(
92
	git_strmap *smcfg, git_index_entry *entry)
93 94 95
{
	git_submodule *sm;
	void *old_sm;
96 97
	khiter_t pos;
	int error;
98

99
	pos = git_strmap_lookup_index(smcfg, entry->path);
100

101 102
	if (git_strmap_valid_index(smcfg, pos))
		sm = git_strmap_value_at(smcfg, pos);
103
	else
104 105 106 107 108 109 110 111 112 113 114 115 116 117
		sm = submodule_alloc(entry->path);

	git_oid_cpy(&sm->oid, &entry->oid);

	if (strcmp(sm->path, entry->path) != 0) {
		if (sm->path != sm->name) {
			git__free(sm->path);
			sm->path = sm->name;
		}
		sm->path = git__strdup(entry->path);
		if (!sm->path)
			goto fail;
	}

118
	git_strmap_insert2(smcfg, sm->path, sm, old_sm, error);
119
	if (error < 0)
120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137
		goto fail;
	sm->refcount++;

	if (old_sm && ((git_submodule *)old_sm) != sm) {
		/* TODO: log warning about multiple entrys for same submodule path */
		submodule_release(old_sm, 1);
	}

	return 0;

fail:
	submodule_release(sm, 0);
	return -1;
}

static int submodule_from_config(
	const char *key, const char *value, void *data)
{
138
	git_strmap *smcfg = data;
139 140 141 142 143 144
	const char *namestart;
	const char *property;
	git_buf name = GIT_BUF_INIT;
	git_submodule *sm;
	void *old_sm = NULL;
	bool is_path;
145 146
	khiter_t pos;
	int error;
147 148 149 150 151 152 153 154 155 156 157 158 159 160

	if (git__prefixcmp(key, "submodule.") != 0)
		return 0;

	namestart = key + strlen("submodule.");
	property  = strrchr(namestart, '.');
	if (property == NULL)
		return 0;
	property++;
	is_path = (strcmp(property, "path") == 0);

	if (git_buf_set(&name, namestart, property - namestart - 1) < 0)
		return -1;

161 162 163 164
	pos = git_strmap_lookup_index(smcfg, name.ptr);
	if (!git_strmap_valid_index(smcfg, pos) && is_path)
		pos = git_strmap_lookup_index(smcfg, value);
	if (!git_strmap_valid_index(smcfg, pos))
165
		sm = submodule_alloc(name.ptr);
166
	else
167
		sm = git_strmap_value_at(smcfg, pos);
168 169 170 171 172 173
	if (!sm)
		goto fail;

	if (strcmp(sm->name, name.ptr) != 0) {
		assert(sm->path == sm->name);
		sm->name = git_buf_detach(&name);
174

175
		git_strmap_insert2(smcfg, sm->name, sm, old_sm, error);
176
		if (error < 0)
177 178 179 180 181
			goto fail;
		sm->refcount++;
	}
	else if (is_path && strcmp(sm->path, value) != 0) {
		assert(sm->path == sm->name);
182 183 184 185
		sm->path = git__strdup(value);
		if (sm->path == NULL)
			goto fail;

186
		git_strmap_insert2(smcfg, sm->path, sm, old_sm, error);
187
		if (error < 0)
188 189 190
			goto fail;
		sm->refcount++;
	}
191
	git_buf_free(&name);
192 193

	if (old_sm && ((git_submodule *)old_sm) != sm) {
194
		/* TODO: log warning about multiple submodules with same path */
195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210
		submodule_release(old_sm, 1);
	}

	if (is_path)
		return 0;

	/* copy other properties into submodule entry */
	if (strcmp(property, "url") == 0) {
		if (sm->url) {
			git__free(sm->url);
			sm->url = NULL;
		}
		if ((sm->url = git__strdup(value)) == NULL)
			goto fail;
	}
	else if (strcmp(property, "update") == 0) {
211 212 213
		int val;
		if (git_config_lookup_map_value(
			_sm_update_map, ARRAY_SIZE(_sm_update_map), value, &val) < 0) {
214 215 216 217 218 219 220
			giterr_set(GITERR_INVALID,
				"Invalid value for submodule update property: '%s'", value);
			goto fail;
		}
		sm->update = (git_submodule_update_t)val;
	}
	else if (strcmp(property, "fetchRecurseSubmodules") == 0) {
221 222 223
		if (git__parse_bool(&sm->fetch_recurse, value) < 0) {
			giterr_set(GITERR_INVALID,
				"Invalid value for submodule 'fetchRecurseSubmodules' property: '%s'", value);
224
			goto fail;
225
		}
226 227
	}
	else if (strcmp(property, "ignore") == 0) {
228 229 230
		int val;
		if (git_config_lookup_map_value(
			_sm_ignore_map, ARRAY_SIZE(_sm_ignore_map), value, &val) < 0) {
231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252
			giterr_set(GITERR_INVALID,
				"Invalid value for submodule ignore property: '%s'", value);
			goto fail;
		}
		sm->ignore = (git_submodule_ignore_t)val;
	}
	/* ignore other unknown submodule properties */

	return 0;

fail:
	submodule_release(sm, 0);
	git_buf_free(&name);
	return -1;
}

static int load_submodule_config(git_repository *repo)
{
	int error;
	git_index *index;
	unsigned int i, max_i;
	git_oid gitmodules_oid;
253
	git_strmap *smcfg;
254 255 256 257 258 259 260 261 262
	struct git_config_file *mods = NULL;

	if (repo->submodules)
		return 0;

	/* submodule data is kept in a hashtable with each submodule stored
	 * under both its name and its path.  These are usually the same, but
	 * that is not guaranteed.
	 */
263
	smcfg = git_strmap_alloc();
264 265 266
	GITERR_CHECK_ALLOC(smcfg);

	/* scan index for gitmodules (and .gitmodules entry) */
267
	if ((error = git_repository_index__weakptr(&index, repo)) < 0)
268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312
		goto cleanup;
	memset(&gitmodules_oid, 0, sizeof(gitmodules_oid));
	max_i = git_index_entrycount(index);

	for (i = 0; i < max_i; i++) {
		git_index_entry *entry = git_index_get(index, i);
		if (S_ISGITLINK(entry->mode)) {
			if ((error = submodule_from_entry(smcfg, entry)) < 0)
				goto cleanup;
		}
		else if (strcmp(entry->path, ".gitmodules") == 0)
			git_oid_cpy(&gitmodules_oid, &entry->oid);
	}

	/* load .gitmodules from workdir if it exists */
	if (git_repository_workdir(repo) != NULL) {
		/* look in workdir for .gitmodules */
		git_buf path = GIT_BUF_INIT;
		if (!git_buf_joinpath(
				&path, git_repository_workdir(repo), ".gitmodules") &&
			git_path_isfile(path.ptr))
		{
			if (!(error = git_config_file__ondisk(&mods, path.ptr)))
				error = git_config_file_open(mods);
		}
		git_buf_free(&path);
	}

	/* load .gitmodules from object cache if not in workdir */
	if (!error && mods == NULL && !git_oid_iszero(&gitmodules_oid)) {
		/* TODO: is it worth loading gitmodules from object cache? */
	}

	/* process .gitmodules info */
	if (!error && mods != NULL)
		error = git_config_file_foreach(mods, submodule_from_config, smcfg);

	/* store submodule config in repo */
	if (!error)
		repo->submodules = smcfg;

cleanup:
	if (mods != NULL)
		git_config_file_free(mods);
	if (error)
313
		git_strmap_free(smcfg);
314 315 316 317 318
	return error;
}

void git_submodule_config_free(git_repository *repo)
{
319
	git_strmap *smcfg = repo->submodules;
320 321 322 323 324 325 326
	git_submodule *sm;

	repo->submodules = NULL;

	if (smcfg == NULL)
		return;

327
	git_strmap_foreach_value(smcfg, sm, {
328 329
		submodule_release(sm,1);
	});
330
	git_strmap_free(smcfg);
331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350
}

static int submodule_cmp(const void *a, const void *b)
{
	return strcmp(((git_submodule *)a)->name, ((git_submodule *)b)->name);
}

int git_submodule_foreach(
	git_repository *repo,
	int (*callback)(const char *name, void *payload),
	void *payload)
{
	int error;
	git_submodule *sm;
	git_vector seen = GIT_VECTOR_INIT;
	seen._cmp = submodule_cmp;

	if ((error = load_submodule_config(repo)) < 0)
		return error;

351
	git_strmap_foreach_value(repo->submodules, sm, {
352 353
		/* usually the following will not come into play */
		if (sm->refcount > 1) {
354
			if (git_vector_bsearch(&seen, sm) != GIT_ENOTFOUND)
355 356
				continue;
			if ((error = git_vector_insert(&seen, sm)) < 0)
357
				break;
358 359 360 361 362
		}

		if ((error = callback(sm->name, payload)) < 0)
			break;
	});
363 364 365 366 367 368 369 370 371 372 373

	git_vector_free(&seen);

	return error;
}

int git_submodule_lookup(
	git_submodule **sm_ptr, /* NULL allowed if user only wants to test */
	git_repository *repo,
	const char *name)       /* trailing slash is allowed */
{
374
	khiter_t pos;
375 376 377 378

	if (load_submodule_config(repo) < 0)
		return -1;

379 380
	pos = git_strmap_lookup_index(repo->submodules, name);
	if (!git_strmap_valid_index(repo->submodules, pos))
381
		return GIT_ENOTFOUND;
382 383

	if (sm_ptr)
384
		*sm_ptr = git_strmap_value_at(repo->submodules, pos);
385

386
	return 0;
387
}