ignore.c 4.9 KB
Newer Older
1 2 3 4 5 6 7
#include "ignore.h"
#include "path.h"

#define GIT_IGNORE_INTERNAL		"[internal]exclude"
#define GIT_IGNORE_FILE_INREPO	"info/exclude"
#define GIT_IGNORE_FILE			".gitignore"

8 9
static int parse_ignore_file(
	git_repository *repo, const char *buffer, git_attr_file *ignores)
10
{
11
	int error = 0;
12 13
	git_attr_fnmatch *match = NULL;
	const char *scan = NULL;
14
	char *context = NULL;
15

16
	GIT_UNUSED(repo);
17

18 19 20
	if (ignores->key && git__suffixcmp(ignores->key, "/" GIT_IGNORE_FILE) == 0) {
		context = ignores->key + 2;
		context[strlen(context) - strlen(GIT_IGNORE_FILE)] = '\0';
21
	}
22

23
	scan = buffer;
24

25 26 27 28
	while (!error && *scan) {
		if (!match) {
			match = git__calloc(1, sizeof(*match));
			GITERR_CHECK_ALLOC(match);
29 30
		}

31 32
		match->flags = GIT_ATTR_FNMATCH_ALLOWSPACE;

33 34 35
		if (!(error = git_attr_fnmatch__parse(
			match, ignores->pool, context, &scan)))
		{
36 37 38 39 40
			match->flags = match->flags | GIT_ATTR_FNMATCH_IGNORE;
			scan = git__next_line(scan);
			error = git_vector_insert(&ignores->rules, match);
		}

41
		if (error != 0) {
42 43 44 45
			git__free(match->pattern);
			match->pattern = NULL;

			if (error == GIT_ENOTFOUND)
46
				error = 0;
47 48 49 50 51
		} else {
			match = NULL; /* vector now "owns" the match */
		}
	}

52
	git__free(match);
53 54 55
	/* restore file path used for context */
	if (context)
		context[strlen(context)] = '.'; /* first char of GIT_IGNORE_FILE */
56 57 58 59

	return error;
}

60 61
#define push_ignore_file(R,S,B,F) \
	git_attr_cache__push_file((R),(B),(F),GIT_ATTR_FILE_FROM_FILE,parse_ignore_file,(S))
62

63 64
static int push_one_ignore(void *ref, git_buf *path)
{
65
	git_ignores *ign = (git_ignores *)ref;
66
	return push_ignore_file(ign->repo, &ign->ign_path, path->ptr, GIT_IGNORE_FILE);
67 68
}

69 70 71 72
int git_ignore__for_path(
	git_repository *repo,
	const char *path,
	git_ignores *ignores)
73
{
74
	int error = 0;
75
	const char *workdir = git_repository_workdir(repo);
76 77

	assert(ignores);
78

79 80 81 82
	ignores->repo = repo;
	git_buf_init(&ignores->dir, 0);
	ignores->ign_internal = NULL;

83 84 85
	if ((error = git_vector_init(&ignores->ign_path, 8, NULL)) < 0 ||
		(error = git_vector_init(&ignores->ign_global, 2, NULL)) < 0 ||
		(error = git_attr_cache__init(repo)) < 0)
86 87
		goto cleanup;

88 89 90 91 92 93
	/* given a unrooted path in a non-bare repo, resolve it */
	if (workdir && git_path_root(path) < 0)
		error = git_path_find_dir(&ignores->dir, path, workdir);
	else
		error = git_buf_sets(&ignores->dir, path);
	if (error < 0)
94 95
		goto cleanup;

96
	/* set up internals */
97 98
	error = git_attr_cache__internal_file(
		repo, GIT_IGNORE_INTERNAL, &ignores->ign_internal);
99
	if (error < 0)
100 101 102
		goto cleanup;

	/* load .gitignore up the path */
103 104 105 106 107 108
	if (workdir != NULL) {
		error = git_path_walk_up(
			&ignores->dir, workdir, push_one_ignore, ignores);
		if (error < 0)
			goto cleanup;
	}
109 110

	/* load .git/info/exclude */
111
	error = push_ignore_file(repo, &ignores->ign_global,
112
		git_repository_path(repo), GIT_IGNORE_FILE_INREPO);
113
	if (error < 0)
114 115 116
		goto cleanup;

	/* load core.excludesfile */
117
	if (git_repository_attr_cache(repo)->cfg_excl_file != NULL)
118
		error = push_ignore_file(repo, &ignores->ign_global, NULL,
119
			git_repository_attr_cache(repo)->cfg_excl_file);
120 121

cleanup:
122
	if (error < 0)
123
		git_ignore__free(ignores);
124

125 126 127 128 129
	return error;
}

int git_ignore__push_dir(git_ignores *ign, const char *dir)
{
130 131 132
	if (git_buf_joinpath(&ign->dir, ign->dir.ptr, dir) < 0)
		return -1;
	else
133
		return push_ignore_file(
134
			ign->repo, &ign->ign_path, ign->dir.ptr, GIT_IGNORE_FILE);
135 136
}

137 138 139 140
int git_ignore__pop_dir(git_ignores *ign)
{
	if (ign->ign_path.length > 0) {
		git_attr_file *file = git_vector_last(&ign->ign_path);
141
		if (git__suffixcmp(ign->dir.ptr, file->key + 2) == 0)
142
			git_vector_pop(&ign->ign_path);
143 144
		git_buf_rtruncate_at_char(&ign->dir, '/');
	}
145
	return 0;
146 147
}

148
void git_ignore__free(git_ignores *ignores)
149
{
150 151 152 153 154 155
	/* don't need to free ignores->ign_internal since it is in cache */
	git_vector_free(&ignores->ign_path);
	git_vector_free(&ignores->ign_global);
	git_buf_free(&ignores->dir);
}

156
static bool ignore_lookup_in_rules(
157 158 159 160 161 162
	git_vector *rules, git_attr_path *path, int *ignored)
{
	unsigned int j;
	git_attr_fnmatch *match;

	git_vector_rforeach(rules, j, match) {
163
		if (git_attr_fnmatch__match(match, path)) {
164
			*ignored = ((match->flags & GIT_ATTR_FNMATCH_NEGATIVE) == 0);
165
			return true;
166 167 168
		}
	}

169
	return false;
170 171
}

172 173
int git_ignore__lookup(
	git_ignores *ignores, const char *pathname, int *ignored)
174
{
175
	unsigned int i;
176 177 178
	git_attr_file *file;
	git_attr_path path;

179 180 181
	if (git_attr_path__init(
		&path, pathname, git_repository_workdir(ignores->repo)) < 0)
		return -1;
182

183 184 185
	/* first process builtins - success means path was found */
	if (ignore_lookup_in_rules(
			&ignores->ign_internal->rules, &path, ignored))
186
		goto cleanup;
187

188 189
	/* next process files in the path */
	git_vector_foreach(&ignores->ign_path, i, file) {
190
		if (ignore_lookup_in_rules(&file->rules, &path, ignored))
191
			goto cleanup;
192 193
	}

194 195
	/* last process global ignores */
	git_vector_foreach(&ignores->ign_global, i, file) {
196
		if (ignore_lookup_in_rules(&file->rules, &path, ignored))
197
			goto cleanup;
198 199 200
	}

	*ignored = 0;
201 202 203

cleanup:
	git_attr_path__free(&path);
204
	return 0;
205
}