]>
Commit | Line | Data |
---|---|---|
eae0bfdc PP |
1 | /* |
2 | * Copyright (C) the libgit2 contributors. All rights reserved. | |
3 | * | |
4 | * This file is part of libgit2, distributed under the GNU GPL v2 with | |
5 | * a Linking Exception. For full terms see the included COPYING file. | |
6 | */ | |
7 | ||
8 | #include "ignore.h" | |
9 | ||
f004c4a8 | 10 | #include "git2/ignore.h" |
157cef10 | 11 | #include "common.h" |
823c0e9c | 12 | #include "attrcache.h" |
df743c7d | 13 | #include "path.h" |
ec40b7f9 | 14 | #include "config.h" |
e05b2ff1 | 15 | #include "fnmatch.h" |
df743c7d RB |
16 | |
17 | #define GIT_IGNORE_INTERNAL "[internal]exclude" | |
df743c7d | 18 | |
02df42dd RB |
19 | #define GIT_IGNORE_DEFAULT_RULES ".\n..\n.git\n" |
20 | ||
4f358603 | 21 | /** |
fcb2c1c8 PS |
22 | * A negative ignore pattern can negate a positive one without |
23 | * wildcards if it is a basename only and equals the basename of | |
24 | * the positive pattern. Thus | |
4f358603 PS |
25 | * |
26 | * foo/bar | |
27 | * !bar | |
28 | * | |
fcb2c1c8 PS |
29 | * would result in foo/bar being unignored again while |
30 | * | |
31 | * moo/foo/bar | |
32 | * !foo/bar | |
33 | * | |
34 | * would do nothing. The reverse also holds true: a positive | |
35 | * basename pattern can be negated by unignoring the basename in | |
36 | * subdirectories. Thus | |
37 | * | |
38 | * bar | |
39 | * !foo/bar | |
40 | * | |
41 | * would result in foo/bar being unignored again. As with the | |
42 | * first case, | |
43 | * | |
44 | * foo/bar | |
45 | * !moo/foo/bar | |
46 | * | |
47 | * would do nothing, again. | |
4f358603 PS |
48 | */ |
49 | static int does_negate_pattern(git_attr_fnmatch *rule, git_attr_fnmatch *neg) | |
50 | { | |
eae0bfdc | 51 | int (*cmp)(const char *, const char *, size_t); |
fcb2c1c8 | 52 | git_attr_fnmatch *longer, *shorter; |
4f358603 PS |
53 | char *p; |
54 | ||
eae0bfdc PP |
55 | if ((rule->flags & GIT_ATTR_FNMATCH_NEGATIVE) != 0 |
56 | || (neg->flags & GIT_ATTR_FNMATCH_NEGATIVE) == 0) | |
57 | return false; | |
58 | ||
59 | if (neg->flags & GIT_ATTR_FNMATCH_ICASE) | |
60 | cmp = git__strncasecmp; | |
61 | else | |
62 | cmp = git__strncmp; | |
63 | ||
64 | /* If lengths match we need to have an exact match */ | |
65 | if (rule->length == neg->length) { | |
66 | return cmp(rule->pattern, neg->pattern, rule->length) == 0; | |
67 | } else if (rule->length < neg->length) { | |
68 | shorter = rule; | |
69 | longer = neg; | |
70 | } else { | |
71 | shorter = neg; | |
72 | longer = rule; | |
73 | } | |
fcb2c1c8 | 74 | |
eae0bfdc PP |
75 | /* Otherwise, we need to check if the shorter |
76 | * rule is a basename only (that is, it contains | |
77 | * no path separator) and, if so, if it | |
78 | * matches the tail of the longer rule */ | |
79 | p = longer->pattern + longer->length - shorter->length; | |
4f358603 | 80 | |
eae0bfdc PP |
81 | if (p[-1] != '/') |
82 | return false; | |
83 | if (memchr(shorter->pattern, '/', shorter->length) != NULL) | |
84 | return false; | |
4f358603 | 85 | |
eae0bfdc | 86 | return cmp(p, shorter->pattern, shorter->length) == 0; |
4f358603 PS |
87 | } |
88 | ||
e05b2ff1 CMN |
89 | /** |
90 | * A negative ignore can only unignore a file which is given explicitly before, thus | |
91 | * | |
92 | * foo | |
93 | * !foo/bar | |
94 | * | |
95 | * does not unignore 'foo/bar' as it's not in the list. However | |
96 | * | |
97 | * foo/<star> | |
98 | * !foo/bar | |
99 | * | |
100 | * does unignore 'foo/bar', as it is contained within the 'foo/<star>' rule. | |
101 | */ | |
102 | static int does_negate_rule(int *out, git_vector *rules, git_attr_fnmatch *match) | |
103 | { | |
eae0bfdc | 104 | int error = 0, fnflags; |
e05b2ff1 CMN |
105 | size_t i; |
106 | git_attr_fnmatch *rule; | |
107 | char *path; | |
108 | git_buf buf = GIT_BUF_INIT; | |
109 | ||
4f358603 PS |
110 | *out = 0; |
111 | ||
eae0bfdc PP |
112 | fnflags = FNM_PATHNAME; |
113 | if (match->flags & GIT_ATTR_FNMATCH_ICASE) | |
114 | fnflags |= FNM_IGNORECASE; | |
115 | ||
e05b2ff1 CMN |
116 | /* path of the file relative to the workdir, so we match the rules in subdirs */ |
117 | if (match->containing_dir) { | |
118 | git_buf_puts(&buf, match->containing_dir); | |
119 | } | |
120 | if (git_buf_puts(&buf, match->pattern) < 0) | |
121 | return -1; | |
122 | ||
123 | path = git_buf_detach(&buf); | |
124 | ||
125 | git_vector_foreach(rules, i, rule) { | |
4f358603 PS |
126 | if (!(rule->flags & GIT_ATTR_FNMATCH_HASWILD)) { |
127 | if (does_negate_pattern(rule, match)) { | |
2c57114f | 128 | error = 0; |
4f358603 PS |
129 | *out = 1; |
130 | goto out; | |
131 | } | |
132 | else | |
133 | continue; | |
134 | } | |
e05b2ff1 | 135 | |
e05b2ff1 | 136 | git_buf_clear(&buf); |
ac3d33df | 137 | if (rule->containing_dir) |
e05b2ff1 | 138 | git_buf_puts(&buf, rule->containing_dir); |
ac3d33df | 139 | git_buf_puts(&buf, rule->pattern); |
657afd35 | 140 | |
ac3d33df | 141 | if (git_buf_oom(&buf)) |
e05b2ff1 CMN |
142 | goto out; |
143 | ||
eae0bfdc | 144 | if ((error = p_fnmatch(git_buf_cstr(&buf), path, fnflags)) < 0) { |
ac3d33df | 145 | git_error_set(GIT_ERROR_INVALID, "error matching pattern"); |
e05b2ff1 CMN |
146 | goto out; |
147 | } | |
148 | ||
149 | /* if we found a match, we want to keep this rule */ | |
150 | if (error != FNM_NOMATCH) { | |
151 | *out = 1; | |
152 | error = 0; | |
153 | goto out; | |
154 | } | |
155 | } | |
156 | ||
e05b2ff1 CMN |
157 | error = 0; |
158 | ||
159 | out: | |
160 | git__free(path); | |
ac3d33df | 161 | git_buf_dispose(&buf); |
e05b2ff1 CMN |
162 | return error; |
163 | } | |
164 | ||
f917481e | 165 | static int parse_ignore_file( |
823c0e9c | 166 | git_repository *repo, git_attr_file *attrs, const char *data) |
df743c7d | 167 | { |
b709e951 | 168 | int error = 0; |
eac76c23 | 169 | int ignore_case = false; |
7d490872 RB |
170 | const char *scan = data, *context = NULL; |
171 | git_attr_fnmatch *match = NULL; | |
ec40b7f9 | 172 | |
823c0e9c | 173 | if (git_repository__cvar(&ignore_case, repo, GIT_CVAR_IGNORECASE) < 0) |
ac3d33df | 174 | git_error_clear(); |
df743c7d | 175 | |
7d490872 | 176 | /* if subdir file path, convert context for file paths */ |
823c0e9c RB |
177 | if (attrs->entry && |
178 | git_path_root(attrs->entry->path) < 0 && | |
179 | !git__suffixcmp(attrs->entry->path, "/" GIT_IGNORE_FILE)) | |
180 | context = attrs->entry->path; | |
df743c7d | 181 | |
e6e8530a | 182 | if (git_mutex_lock(&attrs->lock) < 0) { |
ac3d33df | 183 | git_error_set(GIT_ERROR_OS, "failed to lock ignore file"); |
e6e8530a RB |
184 | return -1; |
185 | } | |
186 | ||
0d0fa7c3 | 187 | while (!error && *scan) { |
e05b2ff1 CMN |
188 | int valid_rule = 1; |
189 | ||
17ef678c RB |
190 | if (!match && !(match = git__calloc(1, sizeof(*match)))) { |
191 | error = -1; | |
192 | break; | |
df743c7d RB |
193 | } |
194 | ||
ac3d33df JK |
195 | match->flags = |
196 | GIT_ATTR_FNMATCH_ALLOWSPACE | | |
197 | GIT_ATTR_FNMATCH_ALLOWNEG | | |
198 | GIT_ATTR_FNMATCH_NOLEADINGDIR; | |
9939e602 | 199 | |
4ba64794 | 200 | if (!(error = git_attr_fnmatch__parse( |
7d490872 | 201 | match, &attrs->pool, context, &scan))) |
19fa2bc1 | 202 | { |
edb456c3 PK |
203 | match->flags |= GIT_ATTR_FNMATCH_IGNORE; |
204 | ||
205 | if (ignore_case) | |
206 | match->flags |= GIT_ATTR_FNMATCH_ICASE; | |
207 | ||
df743c7d | 208 | scan = git__next_line(scan); |
e05b2ff1 | 209 | |
eae0bfdc PP |
210 | /* |
211 | * If a negative match doesn't actually do anything, | |
212 | * throw it away. As we cannot always verify whether a | |
213 | * rule containing wildcards negates another rule, we | |
214 | * do not optimize away these rules, though. | |
215 | * */ | |
216 | if (match->flags & GIT_ATTR_FNMATCH_NEGATIVE | |
217 | && !(match->flags & GIT_ATTR_FNMATCH_HASWILD)) | |
e05b2ff1 CMN |
218 | error = does_negate_rule(&valid_rule, &attrs->rules, match); |
219 | ||
220 | if (!error && valid_rule) | |
221 | error = git_vector_insert(&attrs->rules, match); | |
df743c7d RB |
222 | } |
223 | ||
e05b2ff1 | 224 | if (error != 0 || !valid_rule) { |
df743c7d RB |
225 | match->pattern = NULL; |
226 | ||
227 | if (error == GIT_ENOTFOUND) | |
0d0fa7c3 | 228 | error = 0; |
df743c7d RB |
229 | } else { |
230 | match = NULL; /* vector now "owns" the match */ | |
231 | } | |
232 | } | |
233 | ||
e6e8530a | 234 | git_mutex_unlock(&attrs->lock); |
1dbcc9fc | 235 | git__free(match); |
df743c7d | 236 | |
df743c7d RB |
237 | return error; |
238 | } | |
239 | ||
7d490872 RB |
240 | static int push_ignore_file( |
241 | git_ignores *ignores, | |
242 | git_vector *which_list, | |
243 | const char *base, | |
244 | const char *filename) | |
245 | { | |
246 | int error = 0; | |
247 | git_attr_file *file = NULL; | |
248 | ||
2e9d813b | 249 | error = git_attr_cache__get( |
9f779aac | 250 | &file, ignores->repo, NULL, GIT_ATTR_FILE__FROM_FILE, |
823c0e9c | 251 | base, filename, parse_ignore_file); |
2e9d813b RB |
252 | if (error < 0) |
253 | return error; | |
254 | ||
255 | if (file != NULL) { | |
256 | if ((error = git_vector_insert(which_list, file)) < 0) | |
257 | git_attr_file__free(file); | |
258 | } | |
7d490872 RB |
259 | |
260 | return error; | |
261 | } | |
df743c7d | 262 | |
bbb988a5 | 263 | static int push_one_ignore(void *payload, const char *path) |
0cfcff5d | 264 | { |
25e0b157 | 265 | git_ignores *ign = payload; |
8f7bc646 | 266 | ign->depth++; |
bbb988a5 | 267 | return push_ignore_file(ign, &ign->ign_path, path, GIT_IGNORE_FILE); |
0cfcff5d RB |
268 | } |
269 | ||
7d490872 | 270 | static int get_internal_ignores(git_attr_file **out, git_repository *repo) |
02df42dd RB |
271 | { |
272 | int error; | |
273 | ||
7d490872 RB |
274 | if ((error = git_attr_cache__init(repo)) < 0) |
275 | return error; | |
276 | ||
7d490872 | 277 | error = git_attr_cache__get( |
9f779aac | 278 | out, repo, NULL, GIT_ATTR_FILE__IN_MEMORY, NULL, GIT_IGNORE_INTERNAL, NULL); |
02df42dd | 279 | |
7d490872 RB |
280 | /* if internal rules list is empty, insert default rules */ |
281 | if (!error && !(*out)->rules.length) | |
823c0e9c | 282 | error = parse_ignore_file(repo, *out, GIT_IGNORE_DEFAULT_RULES); |
02df42dd RB |
283 | |
284 | return error; | |
285 | } | |
286 | ||
f917481e RB |
287 | int git_ignore__for_path( |
288 | git_repository *repo, | |
289 | const char *path, | |
290 | git_ignores *ignores) | |
df743c7d | 291 | { |
0d0fa7c3 | 292 | int error = 0; |
df743c7d | 293 | const char *workdir = git_repository_workdir(repo); |
c5f3da96 | 294 | git_buf infopath = GIT_BUF_INIT; |
adc9bdb3 | 295 | |
8a349bf2 | 296 | assert(repo && ignores && path); |
df743c7d | 297 | |
2e9d813b | 298 | memset(ignores, 0, sizeof(*ignores)); |
b6c93aef | 299 | ignores->repo = repo; |
b6c93aef | 300 | |
eac76c23 RB |
301 | /* Read the ignore_case flag */ |
302 | if ((error = git_repository__cvar( | |
303 | &ignores->ignore_case, repo, GIT_CVAR_IGNORECASE)) < 0) | |
ec40b7f9 PK |
304 | goto cleanup; |
305 | ||
2e9d813b | 306 | if ((error = git_attr_cache__init(repo)) < 0) |
df743c7d RB |
307 | goto cleanup; |
308 | ||
f917481e | 309 | /* given a unrooted path in a non-bare repo, resolve it */ |
d364dc8b CMN |
310 | if (workdir && git_path_root(path) < 0) { |
311 | git_buf local = GIT_BUF_INIT; | |
312 | ||
313 | if ((error = git_path_dirname_r(&local, path)) < 0 || | |
314 | (error = git_path_resolve_relative(&local, 0)) < 0 || | |
315 | (error = git_path_to_dir(&local)) < 0 || | |
316 | (error = git_buf_joinpath(&ignores->dir, workdir, local.ptr)) < 0) | |
317 | {;} /* Nothing, we just want to stop on the first error */ | |
ac3d33df | 318 | git_buf_dispose(&local); |
d364dc8b | 319 | } else { |
6a0956e5 | 320 | error = git_buf_joinpath(&ignores->dir, path, ""); |
d364dc8b | 321 | } |
f917481e | 322 | if (error < 0) |
df743c7d RB |
323 | goto cleanup; |
324 | ||
6a0956e5 RB |
325 | if (workdir && !git__prefixcmp(ignores->dir.ptr, workdir)) |
326 | ignores->dir_root = strlen(workdir); | |
327 | ||
b6c93aef | 328 | /* set up internals */ |
7d490872 | 329 | if ((error = get_internal_ignores(&ignores->ign_internal, repo)) < 0) |
df743c7d RB |
330 | goto cleanup; |
331 | ||
332 | /* load .gitignore up the path */ | |
f917481e RB |
333 | if (workdir != NULL) { |
334 | error = git_path_walk_up( | |
25e0b157 | 335 | &ignores->dir, workdir, push_one_ignore, ignores); |
f917481e RB |
336 | if (error < 0) |
337 | goto cleanup; | |
338 | } | |
df743c7d | 339 | |
c5f3da96 PS |
340 | if ((error = git_repository_item_path(&infopath, |
341 | repo, GIT_REPOSITORY_ITEM_INFO)) < 0) | |
342 | goto cleanup; | |
343 | ||
df743c7d | 344 | /* load .git/info/exclude */ |
7d490872 RB |
345 | error = push_ignore_file( |
346 | ignores, &ignores->ign_global, | |
c5f3da96 | 347 | infopath.ptr, GIT_IGNORE_FILE_INREPO); |
0d0fa7c3 | 348 | if (error < 0) |
df743c7d RB |
349 | goto cleanup; |
350 | ||
351 | /* load core.excludesfile */ | |
95dfb031 | 352 | if (git_repository_attr_cache(repo)->cfg_excl_file != NULL) |
7d490872 RB |
353 | error = push_ignore_file( |
354 | ignores, &ignores->ign_global, NULL, | |
95dfb031 | 355 | git_repository_attr_cache(repo)->cfg_excl_file); |
df743c7d RB |
356 | |
357 | cleanup: | |
ac3d33df | 358 | git_buf_dispose(&infopath); |
0d0fa7c3 | 359 | if (error < 0) |
b6c93aef | 360 | git_ignore__free(ignores); |
95dfb031 | 361 | |
b6c93aef RB |
362 | return error; |
363 | } | |
364 | ||
365 | int git_ignore__push_dir(git_ignores *ign, const char *dir) | |
366 | { | |
0d0fa7c3 RB |
367 | if (git_buf_joinpath(&ign->dir, ign->dir.ptr, dir) < 0) |
368 | return -1; | |
ba8b8c04 | 369 | |
8f7bc646 RB |
370 | ign->depth++; |
371 | ||
ba8b8c04 | 372 | return push_ignore_file( |
7d490872 | 373 | ign, &ign->ign_path, ign->dir.ptr, GIT_IGNORE_FILE); |
df743c7d RB |
374 | } |
375 | ||
b6c93aef RB |
376 | int git_ignore__pop_dir(git_ignores *ign) |
377 | { | |
378 | if (ign->ign_path.length > 0) { | |
379 | git_attr_file *file = git_vector_last(&ign->ign_path); | |
823c0e9c | 380 | const char *start = file->entry->path, *end; |
3bc3ed80 | 381 | |
7d490872 RB |
382 | /* - ign->dir looks something like "/home/user/a/b/" (or "a/b/c/d/") |
383 | * - file->path looks something like "a/b/.gitignore | |
3bc3ed80 | 384 | * |
7d490872 RB |
385 | * We are popping the last directory off ign->dir. We also want |
386 | * to remove the file from the vector if the popped directory | |
387 | * matches the ignore path. We need to test if the "a/b" part of | |
3bc3ed80 RB |
388 | * the file key matches the path we are about to pop. |
389 | */ | |
390 | ||
7d490872 RB |
391 | if ((end = strrchr(start, '/')) != NULL) { |
392 | size_t dirlen = (end - start) + 1; | |
6a0956e5 RB |
393 | const char *relpath = ign->dir.ptr + ign->dir_root; |
394 | size_t pathlen = ign->dir.size - ign->dir_root; | |
3bc3ed80 | 395 | |
6a0956e5 | 396 | if (pathlen == dirlen && !memcmp(relpath, start, dirlen)) { |
7d490872 RB |
397 | git_vector_pop(&ign->ign_path); |
398 | git_attr_file__free(file); | |
399 | } | |
cef170ab | 400 | } |
8f7bc646 | 401 | } |
ba8b8c04 | 402 | |
8f7bc646 | 403 | if (--ign->depth > 0) { |
b6c93aef | 404 | git_buf_rtruncate_at_char(&ign->dir, '/'); |
8f7bc646 | 405 | git_path_to_dir(&ign->dir); |
b6c93aef | 406 | } |
8f7bc646 | 407 | |
0d0fa7c3 | 408 | return 0; |
b6c93aef RB |
409 | } |
410 | ||
adc9bdb3 | 411 | void git_ignore__free(git_ignores *ignores) |
df743c7d | 412 | { |
b8777615 RB |
413 | unsigned int i; |
414 | git_attr_file *file; | |
415 | ||
7d490872 | 416 | git_attr_file__free(ignores->ign_internal); |
b8777615 RB |
417 | |
418 | git_vector_foreach(&ignores->ign_path, i, file) { | |
419 | git_attr_file__free(file); | |
420 | ignores->ign_path.contents[i] = NULL; | |
421 | } | |
b6c93aef | 422 | git_vector_free(&ignores->ign_path); |
b8777615 RB |
423 | |
424 | git_vector_foreach(&ignores->ign_global, i, file) { | |
425 | git_attr_file__free(file); | |
426 | ignores->ign_global.contents[i] = NULL; | |
427 | } | |
b6c93aef | 428 | git_vector_free(&ignores->ign_global); |
b8777615 | 429 | |
ac3d33df | 430 | git_buf_dispose(&ignores->dir); |
b6c93aef RB |
431 | } |
432 | ||
0d0fa7c3 | 433 | static bool ignore_lookup_in_rules( |
f554611a | 434 | int *ignored, git_attr_file *file, git_attr_path *path) |
b6c93aef | 435 | { |
b8457baa | 436 | size_t j; |
b6c93aef RB |
437 | git_attr_fnmatch *match; |
438 | ||
e6e8530a | 439 | git_vector_rforeach(&file->rules, j, match) { |
ac3d33df JK |
440 | if (match->flags & GIT_ATTR_FNMATCH_DIRECTORY && |
441 | path->is_dir == GIT_DIR_FLAG_FALSE) | |
442 | continue; | |
ab43ad2f | 443 | if (git_attr_fnmatch__match(match, path)) { |
f554611a RB |
444 | *ignored = ((match->flags & GIT_ATTR_FNMATCH_NEGATIVE) == 0) ? |
445 | GIT_IGNORE_TRUE : GIT_IGNORE_FALSE; | |
0d0fa7c3 | 446 | return true; |
b6c93aef RB |
447 | } |
448 | } | |
449 | ||
0d0fa7c3 | 450 | return false; |
df743c7d RB |
451 | } |
452 | ||
f917481e | 453 | int git_ignore__lookup( |
4c09e19a | 454 | int *out, git_ignores *ignores, const char *pathname, git_dir_flag dir_flag) |
df743c7d | 455 | { |
b6c93aef | 456 | unsigned int i; |
df743c7d RB |
457 | git_attr_file *file; |
458 | git_attr_path path; | |
df743c7d | 459 | |
f554611a RB |
460 | *out = GIT_IGNORE_NOTFOUND; |
461 | ||
0d0fa7c3 | 462 | if (git_attr_path__init( |
4c09e19a | 463 | &path, pathname, git_repository_workdir(ignores->repo), dir_flag) < 0) |
0d0fa7c3 | 464 | return -1; |
df743c7d | 465 | |
0d0fa7c3 | 466 | /* first process builtins - success means path was found */ |
f554611a | 467 | if (ignore_lookup_in_rules(out, ignores->ign_internal, &path)) |
d58336dd | 468 | goto cleanup; |
df743c7d | 469 | |
b6c93aef RB |
470 | /* next process files in the path */ |
471 | git_vector_foreach(&ignores->ign_path, i, file) { | |
f554611a | 472 | if (ignore_lookup_in_rules(out, file, &path)) |
d58336dd | 473 | goto cleanup; |
df743c7d | 474 | } |
df743c7d | 475 | |
b6c93aef RB |
476 | /* last process global ignores */ |
477 | git_vector_foreach(&ignores->ign_global, i, file) { | |
f554611a | 478 | if (ignore_lookup_in_rules(out, file, &path)) |
d58336dd | 479 | goto cleanup; |
b6c93aef RB |
480 | } |
481 | ||
d58336dd RB |
482 | cleanup: |
483 | git_attr_path__free(&path); | |
0d0fa7c3 | 484 | return 0; |
df743c7d | 485 | } |
f004c4a8 | 486 | |
823c0e9c | 487 | int git_ignore_add_rule(git_repository *repo, const char *rules) |
f004c4a8 RB |
488 | { |
489 | int error; | |
7d490872 | 490 | git_attr_file *ign_internal = NULL; |
f004c4a8 | 491 | |
823c0e9c RB |
492 | if ((error = get_internal_ignores(&ign_internal, repo)) < 0) |
493 | return error; | |
494 | ||
495 | error = parse_ignore_file(repo, ign_internal, rules); | |
496 | git_attr_file__free(ign_internal); | |
f004c4a8 RB |
497 | |
498 | return error; | |
499 | } | |
500 | ||
823c0e9c | 501 | int git_ignore_clear_internal_rules(git_repository *repo) |
f004c4a8 RB |
502 | { |
503 | int error; | |
504 | git_attr_file *ign_internal; | |
505 | ||
823c0e9c RB |
506 | if ((error = get_internal_ignores(&ign_internal, repo)) < 0) |
507 | return error; | |
7d490872 | 508 | |
823c0e9c RB |
509 | if (!(error = git_attr_file__clear_rules(ign_internal, true))) |
510 | error = parse_ignore_file( | |
511 | repo, ign_internal, GIT_IGNORE_DEFAULT_RULES); | |
02df42dd | 512 | |
823c0e9c | 513 | git_attr_file__free(ign_internal); |
f004c4a8 RB |
514 | return error; |
515 | } | |
2fb4e9b3 RB |
516 | |
517 | int git_ignore_path_is_ignored( | |
518 | int *ignored, | |
519 | git_repository *repo, | |
52032ae5 | 520 | const char *pathname) |
2fb4e9b3 RB |
521 | { |
522 | int error; | |
52032ae5 RB |
523 | const char *workdir; |
524 | git_attr_path path; | |
2fb4e9b3 | 525 | git_ignores ignores; |
52032ae5 RB |
526 | unsigned int i; |
527 | git_attr_file *file; | |
eae0bfdc | 528 | git_dir_flag dir_flag = GIT_DIR_FLAG_UNKNOWN; |
2fb4e9b3 | 529 | |
8a349bf2 | 530 | assert(repo && ignored && pathname); |
52032ae5 | 531 | |
8a349bf2 | 532 | workdir = git_repository_workdir(repo); |
52032ae5 | 533 | |
f554611a RB |
534 | memset(&path, 0, sizeof(path)); |
535 | memset(&ignores, 0, sizeof(ignores)); | |
52032ae5 | 536 | |
eae0bfdc PP |
537 | if (git_repository_is_bare(repo)) |
538 | dir_flag = GIT_DIR_FLAG_FALSE; | |
539 | ||
540 | if ((error = git_attr_path__init(&path, pathname, workdir, dir_flag)) < 0 || | |
f554611a RB |
541 | (error = git_ignore__for_path(repo, path.path, &ignores)) < 0) |
542 | goto cleanup; | |
2fb4e9b3 | 543 | |
52032ae5 | 544 | while (1) { |
52032ae5 | 545 | /* first process builtins - success means path was found */ |
f554611a | 546 | if (ignore_lookup_in_rules(ignored, ignores.ign_internal, &path)) |
52032ae5 RB |
547 | goto cleanup; |
548 | ||
549 | /* next process files in the path */ | |
550 | git_vector_foreach(&ignores.ign_path, i, file) { | |
f554611a | 551 | if (ignore_lookup_in_rules(ignored, file, &path)) |
52032ae5 RB |
552 | goto cleanup; |
553 | } | |
554 | ||
555 | /* last process global ignores */ | |
556 | git_vector_foreach(&ignores.ign_global, i, file) { | |
f554611a | 557 | if (ignore_lookup_in_rules(ignored, file, &path)) |
52032ae5 RB |
558 | goto cleanup; |
559 | } | |
560 | ||
f554611a RB |
561 | /* move up one directory */ |
562 | if (path.basename == path.path) | |
52032ae5 | 563 | break; |
f554611a RB |
564 | path.basename[-1] = '\0'; |
565 | while (path.basename > path.path && *path.basename != '/') | |
566 | path.basename--; | |
567 | if (path.basename > path.path) | |
568 | path.basename++; | |
569 | path.is_dir = 1; | |
570 | ||
571 | if ((error = git_ignore__pop_dir(&ignores)) < 0) | |
ba8b8c04 | 572 | break; |
52032ae5 RB |
573 | } |
574 | ||
575 | *ignored = 0; | |
576 | ||
577 | cleanup: | |
578 | git_attr_path__free(&path); | |
2fb4e9b3 RB |
579 | git_ignore__free(&ignores); |
580 | return error; | |
581 | } | |
582 | ||
85b8b18b RB |
583 | int git_ignore__check_pathspec_for_exact_ignores( |
584 | git_repository *repo, | |
585 | git_vector *vspec, | |
586 | bool no_fnmatch) | |
587 | { | |
588 | int error = 0; | |
589 | size_t i; | |
590 | git_attr_fnmatch *match; | |
591 | int ignored; | |
592 | git_buf path = GIT_BUF_INIT; | |
593 | const char *wd, *filename; | |
594 | git_index *idx; | |
595 | ||
596 | if ((error = git_repository__ensure_not_bare( | |
597 | repo, "validate pathspec")) < 0 || | |
598 | (error = git_repository_index(&idx, repo)) < 0) | |
599 | return error; | |
600 | ||
601 | wd = git_repository_workdir(repo); | |
602 | ||
603 | git_vector_foreach(vspec, i, match) { | |
604 | /* skip wildcard matches (if they are being used) */ | |
605 | if ((match->flags & GIT_ATTR_FNMATCH_HASWILD) != 0 && | |
606 | !no_fnmatch) | |
607 | continue; | |
608 | ||
609 | filename = match->pattern; | |
610 | ||
611 | /* if file is already in the index, it's fine */ | |
612 | if (git_index_get_bypath(idx, filename, 0) != NULL) | |
613 | continue; | |
614 | ||
615 | if ((error = git_buf_joinpath(&path, wd, filename)) < 0) | |
616 | break; | |
617 | ||
618 | /* is there a file on disk that matches this exactly? */ | |
619 | if (!git_path_isfile(path.ptr)) | |
620 | continue; | |
621 | ||
622 | /* is that file ignored? */ | |
623 | if ((error = git_ignore_path_is_ignored(&ignored, repo, filename)) < 0) | |
624 | break; | |
625 | ||
626 | if (ignored) { | |
ac3d33df | 627 | git_error_set(GIT_ERROR_INVALID, "pathspec contains ignored file '%s'", |
85b8b18b RB |
628 | filename); |
629 | error = GIT_EINVALIDSPEC; | |
630 | break; | |
631 | } | |
632 | } | |
633 | ||
634 | git_index_free(idx); | |
ac3d33df | 635 | git_buf_dispose(&path); |
85b8b18b RB |
636 | |
637 | return error; | |
638 | } | |
639 |