2008-05-24 05:28:56 +00:00
|
|
|
/*
|
|
|
|
* "diff --no-index" support
|
|
|
|
* Copyright (c) 2007 by Johannes Schindelin
|
|
|
|
* Copyright (c) 2008 by Junio C Hamano
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include "cache.h"
|
|
|
|
#include "color.h"
|
|
|
|
#include "commit.h"
|
|
|
|
#include "blob.h"
|
|
|
|
#include "tag.h"
|
|
|
|
#include "diff.h"
|
|
|
|
#include "diffcore.h"
|
|
|
|
#include "revision.h"
|
|
|
|
#include "log-tree.h"
|
|
|
|
#include "builtin.h"
|
2008-07-21 18:03:49 +00:00
|
|
|
#include "string-list.h"
|
2014-03-19 15:58:22 +00:00
|
|
|
#include "dir.h"
|
2008-05-24 05:28:56 +00:00
|
|
|
|
2014-03-19 15:58:21 +00:00
|
|
|
static int read_directory_contents(const char *path, struct string_list *list)
|
2008-05-24 05:28:56 +00:00
|
|
|
{
|
|
|
|
DIR *dir;
|
|
|
|
struct dirent *e;
|
|
|
|
|
|
|
|
if (!(dir = opendir(path)))
|
|
|
|
return error("Could not open directory %s", path);
|
|
|
|
|
|
|
|
while ((e = readdir(dir)))
|
2014-03-19 15:58:22 +00:00
|
|
|
if (!is_dot_or_dotdot(e->d_name))
|
2010-06-25 23:41:35 +00:00
|
|
|
string_list_insert(list, e->d_name);
|
2008-05-24 05:28:56 +00:00
|
|
|
|
|
|
|
closedir(dir);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-06-28 03:14:47 +00:00
|
|
|
/*
|
|
|
|
* This should be "(standard input)" or something, but it will
|
|
|
|
* probably expose many more breakages in the way no-index code
|
|
|
|
* is bolted onto the diff callchain.
|
|
|
|
*/
|
|
|
|
static const char file_from_standard_input[] = "-";
|
|
|
|
|
2008-05-24 05:28:56 +00:00
|
|
|
static int get_mode(const char *path, int *mode)
|
|
|
|
{
|
|
|
|
struct stat st;
|
|
|
|
|
|
|
|
if (!path || !strcmp(path, "/dev/null"))
|
|
|
|
*mode = 0;
|
2013-05-02 19:26:08 +00:00
|
|
|
#ifdef GIT_WINDOWS_NATIVE
|
2009-03-07 15:51:33 +00:00
|
|
|
else if (!strcasecmp(path, "nul"))
|
|
|
|
*mode = 0;
|
|
|
|
#endif
|
2012-06-28 03:14:47 +00:00
|
|
|
else if (path == file_from_standard_input)
|
2008-05-24 05:28:56 +00:00
|
|
|
*mode = create_ce_mode(0666);
|
2009-01-29 16:30:51 +00:00
|
|
|
else if (lstat(path, &st))
|
2008-05-24 05:28:56 +00:00
|
|
|
return error("Could not access '%s'", path);
|
|
|
|
else
|
|
|
|
*mode = st.st_mode;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-06-28 03:14:47 +00:00
|
|
|
static int populate_from_stdin(struct diff_filespec *s)
|
|
|
|
{
|
|
|
|
struct strbuf buf = STRBUF_INIT;
|
|
|
|
size_t size = 0;
|
|
|
|
|
|
|
|
if (strbuf_read(&buf, 0, 0) < 0)
|
2016-05-08 09:47:42 +00:00
|
|
|
return error_errno("error while reading from stdin");
|
2012-06-28 03:14:47 +00:00
|
|
|
|
|
|
|
s->should_munmap = 0;
|
|
|
|
s->data = strbuf_detach(&buf, &size);
|
|
|
|
s->size = size;
|
|
|
|
s->should_free = 1;
|
|
|
|
s->is_stdin = 1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct diff_filespec *noindex_filespec(const char *name, int mode)
|
|
|
|
{
|
|
|
|
struct diff_filespec *s;
|
|
|
|
|
|
|
|
if (!name)
|
|
|
|
name = "/dev/null";
|
|
|
|
s = alloc_filespec(name);
|
2012-08-27 18:54:28 +00:00
|
|
|
fill_filespec(s, null_sha1, 0, mode);
|
2012-06-28 03:14:47 +00:00
|
|
|
if (name == file_from_standard_input)
|
|
|
|
populate_from_stdin(s);
|
|
|
|
return s;
|
|
|
|
}
|
|
|
|
|
2008-05-24 05:28:56 +00:00
|
|
|
static int queue_diff(struct diff_options *o,
|
2012-04-25 19:37:38 +00:00
|
|
|
const char *name1, const char *name2)
|
2008-05-24 05:28:56 +00:00
|
|
|
{
|
|
|
|
int mode1 = 0, mode2 = 0;
|
|
|
|
|
|
|
|
if (get_mode(name1, &mode1) || get_mode(name2, &mode2))
|
|
|
|
return -1;
|
|
|
|
|
2015-03-22 05:11:27 +00:00
|
|
|
if (mode1 && mode2 && S_ISDIR(mode1) != S_ISDIR(mode2)) {
|
|
|
|
struct diff_filespec *d1, *d2;
|
|
|
|
|
|
|
|
if (S_ISDIR(mode1)) {
|
|
|
|
/* 2 is file that is created */
|
|
|
|
d1 = noindex_filespec(NULL, 0);
|
|
|
|
d2 = noindex_filespec(name2, mode2);
|
|
|
|
name2 = NULL;
|
|
|
|
mode2 = 0;
|
|
|
|
} else {
|
|
|
|
/* 1 is file that is deleted */
|
|
|
|
d1 = noindex_filespec(name1, mode1);
|
|
|
|
d2 = noindex_filespec(NULL, 0);
|
|
|
|
name1 = NULL;
|
|
|
|
mode1 = 0;
|
|
|
|
}
|
|
|
|
/* emit that file */
|
|
|
|
diff_queue(&diff_queued_diff, d1, d2);
|
|
|
|
|
|
|
|
/* and then let the entire directory be created or deleted */
|
|
|
|
}
|
2008-05-24 05:28:56 +00:00
|
|
|
|
|
|
|
if (S_ISDIR(mode1) || S_ISDIR(mode2)) {
|
2012-04-25 19:37:38 +00:00
|
|
|
struct strbuf buffer1 = STRBUF_INIT;
|
|
|
|
struct strbuf buffer2 = STRBUF_INIT;
|
2010-07-04 19:46:19 +00:00
|
|
|
struct string_list p1 = STRING_LIST_INIT_DUP;
|
|
|
|
struct string_list p2 = STRING_LIST_INIT_DUP;
|
2012-04-25 19:37:38 +00:00
|
|
|
int i1, i2, ret = 0;
|
2012-05-16 14:28:31 +00:00
|
|
|
size_t len1 = 0, len2 = 0;
|
2008-05-24 05:28:56 +00:00
|
|
|
|
2014-03-19 15:58:21 +00:00
|
|
|
if (name1 && read_directory_contents(name1, &p1))
|
2008-05-24 05:28:56 +00:00
|
|
|
return -1;
|
2014-03-19 15:58:21 +00:00
|
|
|
if (name2 && read_directory_contents(name2, &p2)) {
|
2008-07-21 18:03:49 +00:00
|
|
|
string_list_clear(&p1, 0);
|
2008-05-24 05:28:56 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (name1) {
|
2012-04-25 19:37:38 +00:00
|
|
|
strbuf_addstr(&buffer1, name1);
|
use strbuf_complete to conditionally append slash
When working with paths in strbufs, we frequently want to
ensure that a directory contains a trailing slash before
appending to it. We can shorten this code (and make the
intent more obvious) by calling strbuf_complete.
Most of these cases are trivially identical conversions, but
there are two things to note:
- in a few cases we did not check that the strbuf is
non-empty (which would lead to an out-of-bounds memory
access). These were generally not triggerable in
practice, either from earlier assertions, or typically
because we would have just fed the strbuf to opendir(),
which would choke on an empty path.
- in a few cases we indexed the buffer with "original_len"
or similar, rather than the current sb->len, and it is
not immediately obvious from the diff that they are the
same. In all of these cases, I manually verified that
the strbuf does not change between the assignment and
the strbuf_complete call.
This does not convert cases which look like:
if (sb->len && !is_dir_sep(sb->buf[sb->len - 1]))
strbuf_addch(sb, '/');
as those are obviously semantically different. Some of these
cases arguably should be doing that, but that is out of
scope for this change, which aims purely for cleanup with no
behavior change (and at least it will make such sites easier
to find and examine in the future, as we can grep for
strbuf_complete).
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2015-09-24 21:08:35 +00:00
|
|
|
strbuf_complete(&buffer1, '/');
|
2012-05-16 14:28:31 +00:00
|
|
|
len1 = buffer1.len;
|
2008-05-24 05:28:56 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (name2) {
|
2012-04-25 19:37:38 +00:00
|
|
|
strbuf_addstr(&buffer2, name2);
|
use strbuf_complete to conditionally append slash
When working with paths in strbufs, we frequently want to
ensure that a directory contains a trailing slash before
appending to it. We can shorten this code (and make the
intent more obvious) by calling strbuf_complete.
Most of these cases are trivially identical conversions, but
there are two things to note:
- in a few cases we did not check that the strbuf is
non-empty (which would lead to an out-of-bounds memory
access). These were generally not triggerable in
practice, either from earlier assertions, or typically
because we would have just fed the strbuf to opendir(),
which would choke on an empty path.
- in a few cases we indexed the buffer with "original_len"
or similar, rather than the current sb->len, and it is
not immediately obvious from the diff that they are the
same. In all of these cases, I manually verified that
the strbuf does not change between the assignment and
the strbuf_complete call.
This does not convert cases which look like:
if (sb->len && !is_dir_sep(sb->buf[sb->len - 1]))
strbuf_addch(sb, '/');
as those are obviously semantically different. Some of these
cases arguably should be doing that, but that is out of
scope for this change, which aims purely for cleanup with no
behavior change (and at least it will make such sites easier
to find and examine in the future, as we can grep for
strbuf_complete).
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2015-09-24 21:08:35 +00:00
|
|
|
strbuf_complete(&buffer2, '/');
|
2012-05-16 14:28:31 +00:00
|
|
|
len2 = buffer2.len;
|
2008-05-24 05:28:56 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
for (i1 = i2 = 0; !ret && (i1 < p1.nr || i2 < p2.nr); ) {
|
|
|
|
const char *n1, *n2;
|
|
|
|
int comp;
|
|
|
|
|
2012-05-16 14:28:31 +00:00
|
|
|
strbuf_setlen(&buffer1, len1);
|
|
|
|
strbuf_setlen(&buffer2, len2);
|
|
|
|
|
2008-05-24 05:28:56 +00:00
|
|
|
if (i1 == p1.nr)
|
|
|
|
comp = 1;
|
|
|
|
else if (i2 == p2.nr)
|
|
|
|
comp = -1;
|
|
|
|
else
|
2012-04-25 19:37:38 +00:00
|
|
|
comp = strcmp(p1.items[i1].string, p2.items[i2].string);
|
2008-05-24 05:28:56 +00:00
|
|
|
|
|
|
|
if (comp > 0)
|
|
|
|
n1 = NULL;
|
|
|
|
else {
|
2012-04-25 19:37:38 +00:00
|
|
|
strbuf_addstr(&buffer1, p1.items[i1++].string);
|
|
|
|
n1 = buffer1.buf;
|
2008-05-24 05:28:56 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (comp < 0)
|
|
|
|
n2 = NULL;
|
|
|
|
else {
|
2012-04-25 19:37:38 +00:00
|
|
|
strbuf_addstr(&buffer2, p2.items[i2++].string);
|
|
|
|
n2 = buffer2.buf;
|
2008-05-24 05:28:56 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
ret = queue_diff(o, n1, n2);
|
|
|
|
}
|
2008-07-21 18:03:49 +00:00
|
|
|
string_list_clear(&p1, 0);
|
|
|
|
string_list_clear(&p2, 0);
|
2012-05-16 14:50:31 +00:00
|
|
|
strbuf_release(&buffer1);
|
|
|
|
strbuf_release(&buffer2);
|
2008-05-24 05:28:56 +00:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
} else {
|
|
|
|
struct diff_filespec *d1, *d2;
|
|
|
|
|
|
|
|
if (DIFF_OPT_TST(o, REVERSE_DIFF)) {
|
2017-01-28 21:41:47 +00:00
|
|
|
SWAP(mode1, mode2);
|
2017-01-28 21:40:58 +00:00
|
|
|
SWAP(name1, name2);
|
2008-05-24 05:28:56 +00:00
|
|
|
}
|
|
|
|
|
2012-06-28 03:14:47 +00:00
|
|
|
d1 = noindex_filespec(name1, mode1);
|
|
|
|
d2 = noindex_filespec(name2, mode2);
|
2008-05-24 05:28:56 +00:00
|
|
|
diff_queue(&diff_queued_diff, d1, d2);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-03-25 23:11:39 +00:00
|
|
|
/* append basename of F to D */
|
|
|
|
static void append_basename(struct strbuf *path, const char *dir, const char *file)
|
|
|
|
{
|
|
|
|
const char *tail = strrchr(file, '/');
|
|
|
|
|
|
|
|
strbuf_addstr(path, dir);
|
|
|
|
while (path->len && path->buf[path->len - 1] == '/')
|
|
|
|
path->len--;
|
|
|
|
strbuf_addch(path, '/');
|
|
|
|
strbuf_addstr(path, tail ? tail + 1 : file);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* DWIM "diff D F" into "diff D/F F" and "diff F D" into "diff F D/F"
|
|
|
|
* Note that we append the basename of F to D/, so "diff a/b/file D"
|
|
|
|
* becomes "diff a/b/file D/file", not "diff a/b/file D/a/b/file".
|
|
|
|
*/
|
|
|
|
static void fixup_paths(const char **path, struct strbuf *replacement)
|
|
|
|
{
|
|
|
|
unsigned int isdir0, isdir1;
|
|
|
|
|
|
|
|
if (path[0] == file_from_standard_input ||
|
|
|
|
path[1] == file_from_standard_input)
|
|
|
|
return;
|
|
|
|
isdir0 = is_directory(path[0]);
|
|
|
|
isdir1 = is_directory(path[1]);
|
|
|
|
if (isdir0 == isdir1)
|
|
|
|
return;
|
|
|
|
if (isdir0) {
|
|
|
|
append_basename(replacement, path[0], path[1]);
|
|
|
|
path[0] = replacement->buf;
|
|
|
|
} else {
|
|
|
|
append_basename(replacement, path[1], path[0]);
|
|
|
|
path[1] = replacement->buf;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-05-24 05:28:56 +00:00
|
|
|
void diff_no_index(struct rev_info *revs,
|
2016-01-20 11:06:02 +00:00
|
|
|
int argc, const char **argv)
|
2008-05-24 05:28:56 +00:00
|
|
|
{
|
2017-03-21 01:22:28 +00:00
|
|
|
int i;
|
2012-06-27 18:51:15 +00:00
|
|
|
const char *paths[2];
|
2015-03-25 23:11:39 +00:00
|
|
|
struct strbuf replacement = STRBUF_INIT;
|
2016-01-20 11:06:02 +00:00
|
|
|
const char *prefix = revs->prefix;
|
2008-05-24 05:28:56 +00:00
|
|
|
|
|
|
|
diff_setup(&revs->diffopt);
|
|
|
|
for (i = 1; i < argc - 2; ) {
|
|
|
|
int j;
|
|
|
|
if (!strcmp(argv[i], "--no-index"))
|
|
|
|
i++;
|
2009-01-06 18:53:32 +00:00
|
|
|
else if (!strcmp(argv[i], "--"))
|
|
|
|
i++;
|
2008-05-24 05:28:56 +00:00
|
|
|
else {
|
2016-01-21 11:48:44 +00:00
|
|
|
j = diff_opt_parse(&revs->diffopt, argv + i, argc - i,
|
|
|
|
revs->prefix);
|
diff-no-index: correctly diagnose error return from diff_opt_parse()
diff_opt_parse() returns the number of options parsed, or often
returns error() which is defined to return -1. Yes, return value of
0 is "I did not process that option at all", which should cause the
caller to say that, but negative return should not be forgotten.
This bug caused "diff --no-index" to infinitely show the same error
message because the returned value was used to decrement the loop
control variable, e.g.
$ git diff --no-index --color=words a b
error: option `color' expects "always", "auto", or "never"
error: option `color' expects "always", "auto", or "never"
...
Instead, make it act like so:
$ git diff --no-index --color=words a b
error: option `color' expects "always", "auto", or "never"
fatal: invalid diff option/value: --color=words
Reported-by: Linus Torvalds <torvalds@linux-foundation.org>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2014-03-31 18:47:17 +00:00
|
|
|
if (j <= 0)
|
2008-05-24 05:28:56 +00:00
|
|
|
die("invalid diff option/value: %s", argv[i]);
|
|
|
|
i += j;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-06-27 19:05:52 +00:00
|
|
|
for (i = 0; i < 2; i++) {
|
|
|
|
const char *p = argv[argc - 2 + i];
|
|
|
|
if (!strcmp(p, "-"))
|
2008-05-24 05:28:56 +00:00
|
|
|
/*
|
2012-06-27 19:05:52 +00:00
|
|
|
* stdin should be spelled as "-"; if you have
|
|
|
|
* path that is "-", spell it as "./-".
|
2008-05-24 05:28:56 +00:00
|
|
|
*/
|
2012-06-28 03:14:47 +00:00
|
|
|
p = file_from_standard_input;
|
2017-03-21 01:22:28 +00:00
|
|
|
else if (prefix)
|
2017-03-21 01:28:49 +00:00
|
|
|
p = prefix_filename(prefix, p);
|
2012-06-27 19:05:52 +00:00
|
|
|
paths[i] = p;
|
2008-05-24 05:28:56 +00:00
|
|
|
}
|
2015-03-25 23:11:39 +00:00
|
|
|
|
|
|
|
fixup_paths(paths, &replacement);
|
|
|
|
|
2009-02-18 06:48:06 +00:00
|
|
|
revs->diffopt.skip_stat_unmatch = 1;
|
2009-03-25 17:19:46 +00:00
|
|
|
if (!revs->diffopt.output_format)
|
|
|
|
revs->diffopt.output_format = DIFF_FORMAT_PATCH;
|
2008-05-24 05:28:56 +00:00
|
|
|
|
|
|
|
DIFF_OPT_SET(&revs->diffopt, NO_INDEX);
|
|
|
|
|
diff: handle --no-index prefixes consistently
If we see an explicit "git diff --no-index ../foo ../bar",
then we do not set up the git repository at all (we already
know we are in --no-index mode, so do not have to check "are
we in a repository?"), and hence have no "prefix" within the
repository. A patch generated by this command will have the
filenames "a/../foo" and "b/../bar", no matter which
directory we are in with respect to any repository.
However, in the implicit case, where we notice that the
files are outside the repository, we will have chdir()'d to
the top-level of the repository. We then feed the prefix
back to the diff machinery. As a result, running the same
diff from a subdirectory will result in paths that look like
"a/subdir/../../foo".
Besides being unnecessarily long, this may also be confusing
to the user: they don't care about the subdir or the
repository at all; it's just where they happened to be when
running the command. We should treat this the same as the
explicit --no-index case.
One way to address this would be to chdir() back to the
original path before running our diff. However, that's a bit
hacky, as we would also need to adjust $GIT_DIR, which could
be a relative path from our top-level.
Instead, we can reuse the diff machinery's RELATIVE_NAME
option, which automatically strips off the prefix. Note that
this _also_ restricts the diff to this relative prefix, but
that's OK for our purposes: we queue our own diff pairs
manually, and do not rely on that part of the diff code.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-09-13 03:23:32 +00:00
|
|
|
DIFF_OPT_SET(&revs->diffopt, RELATIVE_NAME);
|
|
|
|
revs->diffopt.prefix = prefix;
|
|
|
|
|
2008-05-24 05:28:56 +00:00
|
|
|
revs->max_count = -2;
|
2012-08-03 12:16:24 +00:00
|
|
|
diff_setup_done(&revs->diffopt);
|
2008-05-24 05:28:56 +00:00
|
|
|
|
2012-06-15 20:32:55 +00:00
|
|
|
setup_diff_pager(&revs->diffopt);
|
|
|
|
DIFF_OPT_SET(&revs->diffopt, EXIT_WITH_STATUS);
|
|
|
|
|
2012-06-27 18:51:15 +00:00
|
|
|
if (queue_diff(&revs->diffopt, paths[0], paths[1]))
|
2008-05-24 05:28:56 +00:00
|
|
|
exit(1);
|
2008-08-19 03:08:09 +00:00
|
|
|
diff_set_mnemonic_prefix(&revs->diffopt, "1/", "2/");
|
2008-05-24 05:28:56 +00:00
|
|
|
diffcore_std(&revs->diffopt);
|
|
|
|
diff_flush(&revs->diffopt);
|
|
|
|
|
2015-03-25 23:11:39 +00:00
|
|
|
strbuf_release(&replacement);
|
|
|
|
|
2008-05-24 05:28:56 +00:00
|
|
|
/*
|
|
|
|
* The return code for --no-index imitates diff(1):
|
|
|
|
* 0 = no changes, 1 = changes, else error
|
|
|
|
*/
|
2012-06-21 18:09:51 +00:00
|
|
|
exit(diff_result_code(&revs->diffopt, 0));
|
2008-05-24 05:28:56 +00:00
|
|
|
}
|