ignore.c 5.49 KB
Newer Older
1 2 3 4 5 6 7 8 9 10
#include "ignore.h"
#include "path.h"
#include "git2/config.h"

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

static int load_ignore_file(
11
	git_repository *repo, const char *path, git_attr_file *ignores)
12 13
{
	int error = GIT_SUCCESS;
14
	git_buf fbuf = GIT_BUF_INIT;
15 16
	git_attr_fnmatch *match = NULL;
	const char *scan = NULL;
17
	char *context = NULL;
18

19 20
	if (ignores->path == NULL)
		error = git_attr_file__set_path(repo, path, ignores);
21

22 23 24 25 26
	if (git__suffixcmp(ignores->path, GIT_IGNORE_FILE) == 0) {
		context = git__strndup(ignores->path,
			strlen(ignores->path) - strlen(GIT_IGNORE_FILE));
		if (!context) error = GIT_ENOMEM;
	}
27

28 29
	if (error == GIT_SUCCESS)
		error = git_futils_readbuffer(&fbuf, path);
30

31
	scan = fbuf.ptr;
32 33 34 35 36 37 38

	while (error == GIT_SUCCESS && *scan) {
		if (!match && !(match = git__calloc(1, sizeof(git_attr_fnmatch)))) {
			error = GIT_ENOMEM;
			break;
		}

39
		if (!(error = git_attr_fnmatch__parse(match, context, &scan))) {
40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55
			match->flags = match->flags | GIT_ATTR_FNMATCH_IGNORE;
			scan = git__next_line(scan);
			error = git_vector_insert(&ignores->rules, match);
		}

		if (error != GIT_SUCCESS) {
			git__free(match->pattern);
			match->pattern = NULL;

			if (error == GIT_ENOTFOUND)
				error = GIT_SUCCESS;
		} else {
			match = NULL; /* vector now "owns" the match */
		}
	}

56
	git_buf_free(&fbuf);
57
	git__free(match);
58
	git__free(context);
59

60
	if (error != GIT_SUCCESS)
61 62 63 64 65 66 67 68
		git__rethrow(error, "Could not open ignore file '%s'", path);

	return error;
}

#define push_ignore(R,S,B,F) \
	git_attr_cache__push_file((R),(S),(B),(F),load_ignore_file)

69 70
static int push_one_ignore(void *ref, git_buf *path)
{
71
	git_ignores *ign = (git_ignores *)ref;
72
	return push_ignore(ign->repo, &ign->ign_path, path->ptr, GIT_IGNORE_FILE);
73 74
}

75
int git_ignore__for_path(git_repository *repo, const char *path, git_ignores *ignores)
76 77 78 79
{
	int error = GIT_SUCCESS;
	git_config *cfg;
	const char *workdir = git_repository_workdir(repo);
80 81

	assert(ignores);
82

83 84 85 86 87 88
	ignores->repo = repo;
	git_buf_init(&ignores->dir, 0);
	ignores->ign_internal = NULL;
	git_vector_init(&ignores->ign_path, 8, NULL);
	git_vector_init(&ignores->ign_global, 2, NULL);

89 90 91
	if ((error = git_attr_cache__init(repo)) < GIT_SUCCESS)
		goto cleanup;

92
	if ((error = git_path_find_dir(&ignores->dir, path, workdir)) < GIT_SUCCESS)
93 94
		goto cleanup;

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

	/* load .gitignore up the path */
102 103
	error = git_path_walk_up(&ignores->dir, workdir, push_one_ignore, ignores);
	if (error < GIT_SUCCESS)
104 105 106
		goto cleanup;

	/* load .git/info/exclude */
107 108 109
	error = push_ignore(repo, &ignores->ign_global,
		repo->path_repository, GIT_IGNORE_FILE_INREPO);
	if (error < GIT_SUCCESS)
110 111 112
		goto cleanup;

	/* load core.excludesfile */
Russell Belfer committed
113
	if ((error = git_repository_config(&cfg, repo)) == GIT_SUCCESS) {
114 115 116
		const char *core_ignore;
		error = git_config_get_string(cfg, GIT_IGNORE_CONFIG, &core_ignore);
		if (error == GIT_SUCCESS && core_ignore != NULL)
117
			error = push_ignore(repo, &ignores->ign_global, NULL, core_ignore);
118 119 120 121 122 123 124 125
		else {
			error = GIT_SUCCESS;
			git_clearerror(); /* don't care if attributesfile is not set */
		}
		git_config_free(cfg);
	}

cleanup:
126 127
	if (error < GIT_SUCCESS) {
		git_ignore__free(ignores);
128
		git__rethrow(error, "Could not get ignore files for '%s'", path);
129
	}
130

131 132 133 134 135 136 137 138 139 140
	return error;
}

int git_ignore__push_dir(git_ignores *ign, const char *dir)
{
	int error = git_buf_joinpath(&ign->dir, ign->dir.ptr, dir);

	if (error == GIT_SUCCESS)
		error = push_ignore(
			ign->repo, &ign->ign_path, ign->dir.ptr, GIT_IGNORE_FILE);
141 142 143 144

	return error;
}

145 146 147 148 149
int git_ignore__pop_dir(git_ignores *ign)
{
	if (ign->ign_path.length > 0) {
		git_attr_file *file = git_vector_last(&ign->ign_path);
		if (git__suffixcmp(ign->dir.ptr, file->path) == 0)
150
			git_vector_pop(&ign->ign_path);
151 152 153 154 155
		git_buf_rtruncate_at_char(&ign->dir, '/');
	}
	return GIT_SUCCESS;
}

156
void git_ignore__free(git_ignores *ignores)
157
{
158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177
	/* 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);
}

static int ignore_lookup_in_rules(
	git_vector *rules, git_attr_path *path, int *ignored)
{
	unsigned int j;
	git_attr_fnmatch *match;

	git_vector_rforeach(rules, j, match) {
		if (git_attr_fnmatch__match(match, path) == GIT_SUCCESS) {
			*ignored = ((match->flags & GIT_ATTR_FNMATCH_NEGATIVE) == 0);
			return GIT_SUCCESS;
		}
	}

	return GIT_ENOTFOUND;
178 179
}

180
int git_ignore__lookup(git_ignores *ignores, const char *pathname, int *ignored)
181 182
{
	int error;
183
	unsigned int i;
184 185 186
	git_attr_file *file;
	git_attr_path path;

187 188
	if ((error = git_attr_path__init(
		&path, pathname, git_repository_workdir(ignores->repo))) < GIT_SUCCESS)
189 190
		return git__rethrow(error, "Could not get attribute for '%s'", pathname);

191 192 193 194 195
	/* first process builtins */
	error = ignore_lookup_in_rules(
		&ignores->ign_internal->rules, &path, ignored);
	if (error == GIT_SUCCESS)
		return error;
196

197 198 199 200 201
	/* next process files in the path */
	git_vector_foreach(&ignores->ign_path, i, file) {
		error = ignore_lookup_in_rules(&file->rules, &path, ignored);
		if (error == GIT_SUCCESS)
			return error;
202 203
	}

204 205 206 207 208 209 210 211 212 213
	/* last process global ignores */
	git_vector_foreach(&ignores->ign_global, i, file) {
		error = ignore_lookup_in_rules(&file->rules, &path, ignored);
		if (error == GIT_SUCCESS)
			return error;
	}

	*ignored = 0;

	return GIT_SUCCESS;
214
}