ignore.c 15.8 KB
Newer Older
1 2 3 4 5 6 7
/*
 * Copyright (C) the libgit2 contributors. All rights reserved.
 *
 * This file is part of libgit2, distributed under the GNU GPL v2 with
 * a Linking Exception. For full terms see the included COPYING file.
 */

8 9
#include "ignore.h"

10
#include "git2/ignore.h"
11
#include "common.h"
12
#include "attrcache.h"
13
#include "fs_path.h"
14
#include "config.h"
15
#include "wildmatch.h"
16
#include "path.h"
17 18 19

#define GIT_IGNORE_INTERNAL		"[internal]exclude"

20 21
#define GIT_IGNORE_DEFAULT_RULES ".\n..\n.git\n"

22
/**
23 24 25
 * A negative ignore pattern can negate a positive one without
 * wildcards if it is a basename only and equals the basename of
 * the positive pattern. Thus
26 27 28 29
 *
 * foo/bar
 * !bar
 *
30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48
 * would result in foo/bar being unignored again while
 *
 * moo/foo/bar
 * !foo/bar
 *
 * would do nothing. The reverse also holds true: a positive
 * basename pattern can be negated by unignoring the basename in
 * subdirectories. Thus
 *
 * bar
 * !foo/bar
 *
 * would result in foo/bar being unignored again. As with the
 * first case,
 *
 * foo/bar
 * !moo/foo/bar
 *
 * would do nothing, again.
49 50 51
 */
static int does_negate_pattern(git_attr_fnmatch *rule, git_attr_fnmatch *neg)
{
52
	int (*cmp)(const char *, const char *, size_t);
53
	git_attr_fnmatch *longer, *shorter;
54 55
	char *p;

56 57 58
	if ((rule->flags & GIT_ATTR_FNMATCH_NEGATIVE) != 0
	    || (neg->flags & GIT_ATTR_FNMATCH_NEGATIVE) == 0)
		return false;
59

60 61 62
	if (neg->flags & GIT_ATTR_FNMATCH_ICASE)
		cmp = git__strncasecmp;
	else
63
		cmp = git__strncmp;
64

65 66
	/* If lengths match we need to have an exact match */
	if (rule->length == neg->length) {
67
		return cmp(rule->pattern, neg->pattern, rule->length) == 0;
68 69 70 71 72 73 74
	} else if (rule->length < neg->length) {
		shorter = rule;
		longer = neg;
	} else {
		shorter = neg;
		longer = rule;
	}
75

76 77 78 79 80
	/* Otherwise, we need to check if the shorter
	 * rule is a basename only (that is, it contains
	 * no path separator) and, if so, if it
	 * matches the tail of the longer rule */
	p = longer->pattern + longer->length - shorter->length;
81

82 83 84 85
	if (p[-1] != '/')
		return false;
	if (memchr(shorter->pattern, '/', shorter->length) != NULL)
		return false;
86

87
	return cmp(p, shorter->pattern, shorter->length) == 0;
88 89 90
}

/**
91 92 93 94 95 96 97 98 99 100 101 102 103 104
 * A negative ignore can only unignore a file which is given explicitly before, thus
 *
 *    foo
 *    !foo/bar
 *
 * does not unignore 'foo/bar' as it's not in the list. However
 *
 *    foo/<star>
 *    !foo/bar
 *
 * does unignore 'foo/bar', as it is contained within the 'foo/<star>' rule.
 */
static int does_negate_rule(int *out, git_vector *rules, git_attr_fnmatch *match)
{
105
	int error = 0, wildmatch_flags, effective_flags;
106 107 108
	size_t i;
	git_attr_fnmatch *rule;
	char *path;
109
	git_str buf = GIT_STR_INIT;
110

111 112
	*out = 0;

113
	wildmatch_flags = WM_PATHNAME;
114
	if (match->flags & GIT_ATTR_FNMATCH_ICASE)
115
		wildmatch_flags |= WM_CASEFOLD;
116

117 118
	/* path of the file relative to the workdir, so we match the rules in subdirs */
	if (match->containing_dir) {
119
		git_str_puts(&buf, match->containing_dir);
120
	}
121
	if (git_str_puts(&buf, match->pattern) < 0)
122 123
		return -1;

124
	path = git_str_detach(&buf);
125 126

	git_vector_foreach(rules, i, rule) {
127 128
		if (!(rule->flags & GIT_ATTR_FNMATCH_HASWILD)) {
			if (does_negate_pattern(rule, match)) {
129
				error = 0;
130 131 132 133 134 135
				*out = 1;
				goto out;
			}
			else
				continue;
		}
136

137
		git_str_clear(&buf);
138
		if (rule->containing_dir)
139 140
			git_str_puts(&buf, rule->containing_dir);
		git_str_puts(&buf, rule->pattern);
141

142
		if (git_str_oom(&buf))
143 144
			goto out;

145 146
		/*
		 * if rule isn't for full path we match without PATHNAME flag
Anders Borum committed
147 148
		 * as lines like *.txt should match something like dir/test.txt
		 * requiring * to also match /
149
		 */
150
		effective_flags = wildmatch_flags;
151
		if (!(rule->flags & GIT_ATTR_FNMATCH_FULLPATH))
152 153
			effective_flags &= ~WM_PATHNAME;

154
		/* if we found a match, we want to keep this rule */
155
		if ((wildmatch(git_str_cstr(&buf), path, effective_flags)) == WM_MATCH) {
156 157 158 159 160 161 162 163 164 165
			*out = 1;
			error = 0;
			goto out;
		}
	}

	error = 0;

out:
	git__free(path);
166
	git_str_dispose(&buf);
167 168 169
	return error;
}

170
static int parse_ignore_file(
171
	git_repository *repo, git_attr_file *attrs, const char *data, bool allow_macros)
172
{
173
	int error = 0;
174
	int ignore_case = false;
175 176
	const char *scan = data, *context = NULL;
	git_attr_fnmatch *match = NULL;
177

178 179
	GIT_UNUSED(allow_macros);

180
	if (git_repository__configmap_lookup(&ignore_case, repo, GIT_CONFIGMAP_IGNORECASE) < 0)
181
		git_error_clear();
182

183
	/* if subdir file path, convert context for file paths */
184
	if (attrs->entry &&
185
		git_fs_path_root(attrs->entry->path) < 0 &&
186 187
		!git__suffixcmp(attrs->entry->path, "/" GIT_IGNORE_FILE))
		context = attrs->entry->path;
188

189
	if (git_mutex_lock(&attrs->lock) < 0) {
190
		git_error_set(GIT_ERROR_OS, "failed to lock ignore file");
191 192 193
		return -1;
	}

194
	while (!error && *scan) {
195 196
		int valid_rule = 1;

197 198 199
		if (!match && !(match = git__calloc(1, sizeof(*match)))) {
			error = -1;
			break;
200 201
		}

202
		match->flags =
203
		    GIT_ATTR_FNMATCH_ALLOWSPACE | GIT_ATTR_FNMATCH_ALLOWNEG;
204

205
		if (!(error = git_attr_fnmatch__parse(
206
			match, &attrs->pool, context, &scan)))
207
		{
208 209 210 211 212
			match->flags |= GIT_ATTR_FNMATCH_IGNORE;

			if (ignore_case)
				match->flags |= GIT_ATTR_FNMATCH_ICASE;

213
			scan = git__next_line(scan);
214

215 216 217 218 219 220 221 222
			/*
			 * If a negative match doesn't actually do anything,
			 * throw it away. As we cannot always verify whether a
			 * rule containing wildcards negates another rule, we
			 * do not optimize away these rules, though.
			 * */
			if (match->flags & GIT_ATTR_FNMATCH_NEGATIVE
			    && !(match->flags & GIT_ATTR_FNMATCH_HASWILD))
223 224 225 226
				error = does_negate_rule(&valid_rule, &attrs->rules, match);

			if (!error && valid_rule)
				error = git_vector_insert(&attrs->rules, match);
227 228
		}

229
		if (error != 0 || !valid_rule) {
230 231 232
			match->pattern = NULL;

			if (error == GIT_ENOTFOUND)
233
				error = 0;
234 235 236 237 238
		} else {
			match = NULL; /* vector now "owns" the match */
		}
	}

239
	git_mutex_unlock(&attrs->lock);
240
	git__free(match);
241 242 243 244

	return error;
}

245 246 247 248 249 250
static int push_ignore_file(
	git_ignores *ignores,
	git_vector *which_list,
	const char *base,
	const char *filename)
{
251
	git_attr_file_source source = { GIT_ATTR_FILE_SOURCE_FILE, base, filename };
252
	git_attr_file *file = NULL;
253
	int error = 0;
254

255
	error = git_attr_cache__get(&file, ignores->repo, NULL, &source, parse_ignore_file, false);
256

257 258 259 260 261 262 263
	if (error < 0)
		return error;

	if (file != NULL) {
		if ((error = git_vector_insert(which_list, file)) < 0)
			git_attr_file__free(file);
	}
264 265 266

	return error;
}
267

268
static int push_one_ignore(void *payload, const char *path)
269
{
270
	git_ignores *ign = payload;
271
	ign->depth++;
272
	return push_ignore_file(ign, &ign->ign_path, path, GIT_IGNORE_FILE);
273 274
}

275
static int get_internal_ignores(git_attr_file **out, git_repository *repo)
276
{
277
	git_attr_file_source source = { GIT_ATTR_FILE_SOURCE_MEMORY, NULL, GIT_IGNORE_INTERNAL };
278 279
	int error;

280 281 282
	if ((error = git_attr_cache__init(repo)) < 0)
		return error;

283
	error = git_attr_cache__get(out, repo, NULL, &source, NULL, false);
284

285 286
	/* if internal rules list is empty, insert default rules */
	if (!error && !(*out)->rules.length)
287
		error = parse_ignore_file(repo, *out, GIT_IGNORE_DEFAULT_RULES, false);
288 289 290 291

	return error;
}

292 293 294 295
int git_ignore__for_path(
	git_repository *repo,
	const char *path,
	git_ignores *ignores)
296
{
297
	int error = 0;
298
	const char *workdir = git_repository_workdir(repo);
299
	git_str infopath = GIT_STR_INIT;
300

301 302 303
	GIT_ASSERT_ARG(repo);
	GIT_ASSERT_ARG(ignores);
	GIT_ASSERT_ARG(path);
304

305
	memset(ignores, 0, sizeof(*ignores));
306 307
	ignores->repo = repo;

308
	/* Read the ignore_case flag */
309 310
	if ((error = git_repository__configmap_lookup(
			&ignores->ignore_case, repo, GIT_CONFIGMAP_IGNORECASE)) < 0)
311 312
		goto cleanup;

313
	if ((error = git_attr_cache__init(repo)) < 0)
314 315
		goto cleanup;

316
	/* given a unrooted path in a non-bare repo, resolve it */
317
	if (workdir && git_fs_path_root(path) < 0) {
318
		git_str local = GIT_STR_INIT;
319

320 321 322
		if ((error = git_fs_path_dirname_r(&local, path)) < 0 ||
		    (error = git_fs_path_resolve_relative(&local, 0)) < 0 ||
		    (error = git_fs_path_to_dir(&local)) < 0 ||
323
		    (error = git_str_joinpath(&ignores->dir, workdir, local.ptr)) < 0 ||
324
		    (error = git_path_validate_str_length(repo, &ignores->dir)) < 0) {
325 326 327
			/* Nothing, we just want to stop on the first error */
		}

328
		git_str_dispose(&local);
329
	} else {
330
		if (!(error = git_str_joinpath(&ignores->dir, path, "")))
331
		    error = git_path_validate_str_length(NULL, &ignores->dir);
332
	}
333

334
	if (error < 0)
335 336
		goto cleanup;

337 338 339
	if (workdir && !git__prefixcmp(ignores->dir.ptr, workdir))
		ignores->dir_root = strlen(workdir);

340
	/* set up internals */
341
	if ((error = get_internal_ignores(&ignores->ign_internal, repo)) < 0)
342 343 344
		goto cleanup;

	/* load .gitignore up the path */
345
	if (workdir != NULL) {
346
		error = git_fs_path_walk_up(
347
			&ignores->dir, workdir, push_one_ignore, ignores);
348 349 350
		if (error < 0)
			goto cleanup;
	}
351

352
	/* load .git/info/exclude if possible */
353
	if ((error = git_repository__item_path(&infopath, repo, GIT_REPOSITORY_ITEM_INFO)) < 0 ||
354 355 356 357 358
		(error = push_ignore_file(ignores, &ignores->ign_global, infopath.ptr, GIT_IGNORE_FILE_INREPO)) < 0) {
		if (error != GIT_ENOTFOUND)
			goto cleanup;
		error = 0;
	}
359 360

	/* load core.excludesfile */
361
	if (git_repository_attr_cache(repo)->cfg_excl_file != NULL)
362 363
		error = push_ignore_file(
			ignores, &ignores->ign_global, NULL,
364
			git_repository_attr_cache(repo)->cfg_excl_file);
365 366

cleanup:
367
	git_str_dispose(&infopath);
368
	if (error < 0)
369
		git_ignore__free(ignores);
370

371 372 373 374 375
	return error;
}

int git_ignore__push_dir(git_ignores *ign, const char *dir)
{
376
	if (git_str_joinpath(&ign->dir, ign->dir.ptr, dir) < 0)
377
		return -1;
378

379 380
	ign->depth++;

381
	return push_ignore_file(
382
		ign, &ign->ign_path, ign->dir.ptr, GIT_IGNORE_FILE);
383 384
}

385 386 387 388
int git_ignore__pop_dir(git_ignores *ign)
{
	if (ign->ign_path.length > 0) {
		git_attr_file *file = git_vector_last(&ign->ign_path);
389
		const char *start = file->entry->path, *end;
390

391 392
		/* - ign->dir looks something like "/home/user/a/b/" (or "a/b/c/d/")
		 * - file->path looks something like "a/b/.gitignore
393
		 *
394 395 396
		 * We are popping the last directory off ign->dir.  We also want
		 * to remove the file from the vector if the popped directory
		 * matches the ignore path.  We need to test if the "a/b" part of
397 398 399
		 * the file key matches the path we are about to pop.
		 */

400 401
		if ((end = strrchr(start, '/')) != NULL) {
			size_t dirlen = (end - start) + 1;
402 403
			const char *relpath = ign->dir.ptr + ign->dir_root;
			size_t pathlen = ign->dir.size - ign->dir_root;
404

405
			if (pathlen == dirlen && !memcmp(relpath, start, dirlen)) {
406 407 408
				git_vector_pop(&ign->ign_path);
				git_attr_file__free(file);
			}
409
		}
410
	}
411

412
	if (--ign->depth > 0) {
413
		git_str_rtruncate_at_char(&ign->dir, '/');
414
		git_fs_path_to_dir(&ign->dir);
415
	}
416

417
	return 0;
418 419
}

420
void git_ignore__free(git_ignores *ignores)
421
{
422 423 424
	unsigned int i;
	git_attr_file *file;

425
	git_attr_file__free(ignores->ign_internal);
426 427 428 429 430

	git_vector_foreach(&ignores->ign_path, i, file) {
		git_attr_file__free(file);
		ignores->ign_path.contents[i] = NULL;
	}
431
	git_vector_free(&ignores->ign_path);
432 433 434 435 436

	git_vector_foreach(&ignores->ign_global, i, file) {
		git_attr_file__free(file);
		ignores->ign_global.contents[i] = NULL;
	}
437
	git_vector_free(&ignores->ign_global);
438

439
	git_str_dispose(&ignores->dir);
440 441
}

442
static bool ignore_lookup_in_rules(
443
	int *ignored, git_attr_file *file, git_attr_path *path)
444
{
445
	size_t j;
446 447
	git_attr_fnmatch *match;

448
	git_vector_rforeach(&file->rules, j, match) {
449 450 451
		if (match->flags & GIT_ATTR_FNMATCH_DIRECTORY &&
		    path->is_dir == GIT_DIR_FLAG_FALSE)
			continue;
452
		if (git_attr_fnmatch__match(match, path)) {
453 454
			*ignored = ((match->flags & GIT_ATTR_FNMATCH_NEGATIVE) == 0) ?
				GIT_IGNORE_TRUE : GIT_IGNORE_FALSE;
455
			return true;
456 457 458
		}
	}

459
	return false;
460 461
}

462
int git_ignore__lookup(
463
	int *out, git_ignores *ignores, const char *pathname, git_dir_flag dir_flag)
464
{
465
	size_t i;
466 467 468
	git_attr_file *file;
	git_attr_path path;

469 470
	*out = GIT_IGNORE_NOTFOUND;

471
	if (git_attr_path__init(
472
		&path, pathname, git_repository_workdir(ignores->repo), dir_flag) < 0)
473
		return -1;
474

475
	/* first process builtins - success means path was found */
476
	if (ignore_lookup_in_rules(out, ignores->ign_internal, &path))
477
		goto cleanup;
478

479 480 481 482 483
	/* next process files in the path.
	 * this process has to process ignores in reverse order
	 * to ensure correct prioritization of rules
	 */
	git_vector_rforeach(&ignores->ign_path, i, file) {
484
		if (ignore_lookup_in_rules(out, file, &path))
485
			goto cleanup;
486 487
	}

488 489
	/* last process global ignores */
	git_vector_foreach(&ignores->ign_global, i, file) {
490
		if (ignore_lookup_in_rules(out, file, &path))
491
			goto cleanup;
492 493
	}

494 495
cleanup:
	git_attr_path__free(&path);
496
	return 0;
497
}
498

499
int git_ignore_add_rule(git_repository *repo, const char *rules)
500 501
{
	int error;
502
	git_attr_file *ign_internal = NULL;
503

504 505 506
	if ((error = get_internal_ignores(&ign_internal, repo)) < 0)
		return error;

507
	error = parse_ignore_file(repo, ign_internal, rules, false);
508
	git_attr_file__free(ign_internal);
509 510 511 512

	return error;
}

513
int git_ignore_clear_internal_rules(git_repository *repo)
514 515 516 517
{
	int error;
	git_attr_file *ign_internal;

518 519
	if ((error = get_internal_ignores(&ign_internal, repo)) < 0)
		return error;
520

521 522
	if (!(error = git_attr_file__clear_rules(ign_internal, true)))
		error = parse_ignore_file(
523
				repo, ign_internal, GIT_IGNORE_DEFAULT_RULES, false);
524

525
	git_attr_file__free(ign_internal);
526 527
	return error;
}
528 529 530 531

int git_ignore_path_is_ignored(
	int *ignored,
	git_repository *repo,
532
	const char *pathname)
533 534
{
	int error;
535 536
	const char *workdir;
	git_attr_path path;
537
	git_ignores ignores;
538 539
	unsigned int i;
	git_attr_file *file;
540
	git_dir_flag dir_flag = GIT_DIR_FLAG_UNKNOWN;
541

542 543 544
	GIT_ASSERT_ARG(repo);
	GIT_ASSERT_ARG(ignored);
	GIT_ASSERT_ARG(pathname);
545

546
	workdir = git_repository_workdir(repo);
547

548 549
	memset(&path, 0, sizeof(path));
	memset(&ignores, 0, sizeof(ignores));
550

551 552 553
	if (!git__suffixcmp(pathname, "/"))
		dir_flag = GIT_DIR_FLAG_TRUE;
	else if (git_repository_is_bare(repo))
554 555
		dir_flag = GIT_DIR_FLAG_FALSE;

556
	if ((error = git_attr_path__init(&path, pathname, workdir, dir_flag)) < 0 ||
557 558
		(error = git_ignore__for_path(repo, path.path, &ignores)) < 0)
		goto cleanup;
559

560 561
	while (1) {
		/* first process builtins - success means path was found */
562
		if (ignore_lookup_in_rules(ignored, ignores.ign_internal, &path))
563 564 565 566
			goto cleanup;

		/* next process files in the path */
		git_vector_foreach(&ignores.ign_path, i, file) {
567
			if (ignore_lookup_in_rules(ignored, file, &path))
568 569 570 571 572
				goto cleanup;
		}

		/* last process global ignores */
		git_vector_foreach(&ignores.ign_global, i, file) {
573
			if (ignore_lookup_in_rules(ignored, file, &path))
574 575 576
				goto cleanup;
		}

577 578
		/* move up one directory */
		if (path.basename == path.path)
579
			break;
580 581 582 583 584 585 586 587
		path.basename[-1] = '\0';
		while (path.basename > path.path && *path.basename != '/')
			path.basename--;
		if (path.basename > path.path)
			path.basename++;
		path.is_dir = 1;

		if ((error = git_ignore__pop_dir(&ignores)) < 0)
588
			break;
589 590 591 592 593 594
	}

	*ignored = 0;

cleanup:
	git_attr_path__free(&path);
595 596 597 598
	git_ignore__free(&ignores);
	return error;
}

599 600 601 602 603 604 605 606 607
int git_ignore__check_pathspec_for_exact_ignores(
	git_repository *repo,
	git_vector *vspec,
	bool no_fnmatch)
{
	int error = 0;
	size_t i;
	git_attr_fnmatch *match;
	int ignored;
608
	git_str path = GIT_STR_INIT;
609
	const char *filename;
610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628
	git_index *idx;

	if ((error = git_repository__ensure_not_bare(
			repo, "validate pathspec")) < 0 ||
		(error = git_repository_index(&idx, repo)) < 0)
		return error;

	git_vector_foreach(vspec, i, match) {
		/* skip wildcard matches (if they are being used) */
		if ((match->flags & GIT_ATTR_FNMATCH_HASWILD) != 0 &&
			!no_fnmatch)
			continue;

		filename = match->pattern;

		/* if file is already in the index, it's fine */
		if (git_index_get_bypath(idx, filename, 0) != NULL)
			continue;

629
		if ((error = git_repository_workdir_path(&path, repo, filename)) < 0)
630 631 632
			break;

		/* is there a file on disk that matches this exactly? */
633
		if (!git_fs_path_isfile(path.ptr))
634 635 636 637 638 639 640
			continue;

		/* is that file ignored? */
		if ((error = git_ignore_path_is_ignored(&ignored, repo, filename)) < 0)
			break;

		if (ignored) {
641
			git_error_set(GIT_ERROR_INVALID, "pathspec contains ignored file '%s'",
642 643 644 645 646 647 648
				filename);
			error = GIT_EINVALIDSPEC;
			break;
		}
	}

	git_index_free(idx);
649
	git_str_dispose(&path);
650 651 652

	return error;
}