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