2005-04-07 22:16:10 +00:00
|
|
|
/*
|
|
|
|
* GIT - The information manager from hell
|
|
|
|
*
|
|
|
|
* Copyright (C) Linus Torvalds, 2005
|
|
|
|
*/
|
2023-05-16 06:33:57 +00:00
|
|
|
#include "builtin.h"
|
2017-06-14 18:07:36 +00:00
|
|
|
#include "config.h"
|
2005-04-27 16:21:00 +00:00
|
|
|
#include "diff.h"
|
2020-12-21 15:19:39 +00:00
|
|
|
#include "diff-merges.h"
|
Log message printout cleanups
On Sun, 16 Apr 2006, Junio C Hamano wrote:
>
> In the mid-term, I am hoping we can drop the generate_header()
> callchain _and_ the custom code that formats commit log in-core,
> found in cmd_log_wc().
Ok, this was nastier than expected, just because the dependencies between
the different log-printing stuff were absolutely _everywhere_, but here's
a patch that does exactly that.
The patch is not very easy to read, and the "--patch-with-stat" thing is
still broken (it does not call the "show_log()" thing properly for
merges). That's not a new bug. In the new world order it _should_ do
something like
if (rev->logopt)
show_log(rev, rev->logopt, "---\n");
but it doesn't. I haven't looked at the --with-stat logic, so I left it
alone.
That said, this patch removes more lines than it adds, and in particular,
the "cmd_log_wc()" loop is now a very clean:
while ((commit = get_revision(rev)) != NULL) {
log_tree_commit(rev, commit);
free(commit->buffer);
commit->buffer = NULL;
}
so it doesn't get much prettier than this. All the complexity is entirely
hidden in log-tree.c, and any code that needs to flush the log literally
just needs to do the "if (rev->logopt) show_log(...)" incantation.
I had to make the combined_diff() logic take a "struct rev_info" instead
of just a "struct diff_options", but that part is pretty clean.
This does change "git whatchanged" from using "diff-tree" as the commit
descriptor to "commit", and I changed one of the tests to reflect that new
reality. Otherwise everything still passes, and my other tests look fine
too.
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-04-17 18:59:32 +00:00
|
|
|
#include "commit.h"
|
2023-05-16 06:33:52 +00:00
|
|
|
#include "preload-index.h"
|
2023-05-16 06:34:00 +00:00
|
|
|
#include "repository.h"
|
Log message printout cleanups
On Sun, 16 Apr 2006, Junio C Hamano wrote:
>
> In the mid-term, I am hoping we can drop the generate_header()
> callchain _and_ the custom code that formats commit log in-core,
> found in cmd_log_wc().
Ok, this was nastier than expected, just because the dependencies between
the different log-printing stuff were absolutely _everywhere_, but here's
a patch that does exactly that.
The patch is not very easy to read, and the "--patch-with-stat" thing is
still broken (it does not call the "show_log()" thing properly for
merges). That's not a new bug. In the new world order it _should_ do
something like
if (rev->logopt)
show_log(rev, rev->logopt, "---\n");
but it doesn't. I haven't looked at the --with-stat logic, so I left it
alone.
That said, this patch removes more lines than it adds, and in particular,
the "cmd_log_wc()" loop is now a very clean:
while ((commit = get_revision(rev)) != NULL) {
log_tree_commit(rev, commit);
free(commit->buffer);
commit->buffer = NULL;
}
so it doesn't get much prettier than this. All the complexity is entirely
hidden in log-tree.c, and any code that needs to flush the log literally
just needs to do the "if (rev->logopt) show_log(...)" incantation.
I had to make the combined_diff() logic take a "struct rev_info" instead
of just a "struct diff_options", but that part is pretty clean.
This does change "git whatchanged" from using "diff-tree" as the commit
descriptor to "commit", and I changed one of the tests to reflect that new
reality. Otherwise everything still passes, and my other tests look fine
too.
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-04-17 18:59:32 +00:00
|
|
|
#include "revision.h"
|
2005-04-12 09:04:44 +00:00
|
|
|
|
2005-07-29 09:01:26 +00:00
|
|
|
static const char diff_files_usage[] =
|
2015-01-13 07:44:47 +00:00
|
|
|
"git diff-files [-q] [-0 | -1 | -2 | -3 | -c | --cc] [<common-diff-options>] [<path>...]"
|
2022-10-13 15:39:01 +00:00
|
|
|
"\n"
|
2005-07-13 19:52:35 +00:00
|
|
|
COMMON_DIFF_OPTIONS_HELP;
|
2005-04-17 04:29:45 +00:00
|
|
|
|
2006-07-29 05:44:25 +00:00
|
|
|
int cmd_diff_files(int argc, const char **argv, const char *prefix)
|
2005-04-07 22:13:13 +00:00
|
|
|
{
|
2006-04-22 06:57:45 +00:00
|
|
|
struct rev_info rev;
|
2007-03-14 00:17:04 +00:00
|
|
|
int result;
|
2008-05-24 01:15:03 +00:00
|
|
|
unsigned options = 0;
|
2005-04-07 22:13:13 +00:00
|
|
|
|
2017-06-01 04:38:16 +00:00
|
|
|
if (argc == 2 && !strcmp(argv[1], "-h"))
|
|
|
|
usage(diff_files_usage);
|
|
|
|
|
2017-05-08 16:03:37 +00:00
|
|
|
git_config(git_diff_basic_config, NULL); /* no "diff" UI options */
|
2023-05-09 19:42:41 +00:00
|
|
|
|
|
|
|
prepare_repo_settings(the_repository);
|
|
|
|
the_repository->settings.command_requires_full_index = 0;
|
|
|
|
|
2018-09-21 15:57:38 +00:00
|
|
|
repo_init_revisions(the_repository, &rev, prefix);
|
2006-04-22 06:57:45 +00:00
|
|
|
rev.abbrev = 0;
|
2020-06-20 16:38:45 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Consider "intent-to-add" files as new by default, unless
|
|
|
|
* explicitly specified in the command line or anywhere else.
|
|
|
|
*/
|
|
|
|
rev.diffopt.ita_invisible_in_index = 1;
|
|
|
|
|
MacOS: precompose_argv_prefix()
The following sequence leads to a "BUG" assertion running under MacOS:
DIR=git-test-restore-p
Adiarnfd=$(printf 'A\314\210')
DIRNAME=xx${Adiarnfd}yy
mkdir $DIR &&
cd $DIR &&
git init &&
mkdir $DIRNAME &&
cd $DIRNAME &&
echo "Initial" >file &&
git add file &&
echo "One more line" >>file &&
echo y | git restore -p .
Initialized empty Git repository in /tmp/git-test-restore-p/.git/
BUG: pathspec.c:495: error initializing pathspec_item
Cannot close git diff-index --cached --numstat
[snip]
The command `git restore` is run from a directory inside a Git repo.
Git needs to split the $CWD into 2 parts:
The path to the repo and "the rest", if any.
"The rest" becomes a "prefix" later used inside the pathspec code.
As an example, "/path/to/repo/dir-inside-repå" would determine
"/path/to/repo" as the root of the repo, the place where the
configuration file .git/config is found.
The rest becomes the prefix ("dir-inside-repå"), from where the
pathspec machinery expands the ".", more about this later.
If there is a decomposed form, (making the decomposing visible like this),
"dir-inside-rep°a" doesn't match "dir-inside-repå".
Git commands need to:
(a) read the configuration variable "core.precomposeunicode"
(b) precocompose argv[]
(c) precompose the prefix, if there was any
The first commit,
76759c7dff53 "git on Mac OS and precomposed unicode"
addressed (a) and (b).
The call to precompose_argv() was added into parse-options.c,
because that seemed to be a good place when the patch was written.
Commands that don't use parse-options need to do (a) and (b) themselfs.
The commands `diff-files`, `diff-index`, `diff-tree` and `diff`
learned (a) and (b) in
commit 90a78b83e0b8 "diff: run arguments through precompose_argv"
Branch names (or refs in general) using decomposed code points
resulting in decomposed file names had been fixed in
commit 8e712ef6fc97 "Honor core.precomposeUnicode in more places"
The bug report from above shows 2 things:
- more commands need to handle precomposed unicode
- (c) should be implemented for all commands using pathspecs
Solution:
precompose_argv() now handles the prefix (if needed), and is renamed into
precompose_argv_prefix().
Inside this function the config variable core.precomposeunicode is read
into the global variable precomposed_unicode, as before.
This reading is skipped if precomposed_unicode had been read before.
The original patch for preocomposed unicode, 76759c7dff53, placed
precompose_argv() into parse-options.c
Now add it into git.c::run_builtin() as well. Existing precompose
calls in diff-files.c and others may become redundant, and if we
audit the callflows that reach these places to make sure that they
can never be reached without going through the new call added to
run_builtin(), we might be able to remove these existing ones.
But in this commit, we do not bother to do so and leave these
precompose callsites as they are. Because precompose() is
idempotent and can be called on an already precomposed string
safely, this is safer than removing existing calls without fully
vetting the callflows.
There is certainly room for cleanups - this change intends to be a bug fix.
Cleanups needs more tests in e.g. t/t3910-mac-os-precompose.sh, and should
be done in future commits.
[1] git-bugreport-2021-01-06-1209.txt (git can't deal with special characters)
[2] https://lore.kernel.org/git/A102844A-9501-4A86-854D-E3B387D378AA@icloud.com/
Reported-by: Daniel Troger <random_n0body@icloud.com>
Helped-By: Philippe Blain <levraiphilippeblain@gmail.com>
Signed-off-by: Torsten Bögershausen <tboegi@web.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2021-02-03 16:28:23 +00:00
|
|
|
prefix = precompose_argv_prefix(argc, argv, prefix);
|
2006-04-22 06:57:45 +00:00
|
|
|
|
2008-05-24 01:15:03 +00:00
|
|
|
argc = setup_revisions(argc, argv, &rev, NULL);
|
|
|
|
while (1 < argc && argv[1][0] == '-') {
|
|
|
|
if (!strcmp(argv[1], "--base"))
|
|
|
|
rev.max_count = 1;
|
|
|
|
else if (!strcmp(argv[1], "--ours"))
|
|
|
|
rev.max_count = 2;
|
|
|
|
else if (!strcmp(argv[1], "--theirs"))
|
|
|
|
rev.max_count = 3;
|
|
|
|
else if (!strcmp(argv[1], "-q"))
|
|
|
|
options |= DIFF_SILENT_ON_REMOVED;
|
|
|
|
else
|
|
|
|
usage(diff_files_usage);
|
|
|
|
argv++; argc--;
|
|
|
|
}
|
2006-06-24 17:24:14 +00:00
|
|
|
if (!rev.diffopt.output_format)
|
|
|
|
rev.diffopt.output_format = DIFF_FORMAT_RAW;
|
diff: --{rotate,skip}-to=<path>
In the implementation of "git difftool", there is a case where the
user wants to start viewing the diffs at a specific path and
continue on to the rest, optionally wrapping around to the
beginning. Since it is somewhat cumbersome to implement such a
feature as a post-processing step of "git diff" output, let's
support it internally with two new options.
- "git diff --rotate-to=C", when the resulting patch would show
paths A B C D E without the option, would "rotate" the paths to
shows patch to C D E A B instead. It is an error when there is
no patch for C is shown.
- "git diff --skip-to=C" would instead "skip" the paths before C,
and shows patch to C D E. Again, it is an error when there is no
patch for C is shown.
- "git log [-p]" also accepts these two options, but it is not an
error if there is no change to the specified path. Instead, the
set of output paths are rotated or skipped to the specified path
or the first path that sorts after the specified path.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2021-02-11 19:57:50 +00:00
|
|
|
rev.diffopt.rotate_to_strict = 1;
|
2008-05-24 01:15:03 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Make sure there are NO revision (i.e. pending object) parameter,
|
|
|
|
* rev.max_count is reasonable (0 <= n <= 3), and
|
|
|
|
* there is no other revision filtering parameters.
|
|
|
|
*/
|
|
|
|
if (rev.pending.nr ||
|
|
|
|
rev.min_age != -1 || rev.max_age != -1 ||
|
|
|
|
3 < rev.max_count)
|
|
|
|
usage(diff_files_usage);
|
|
|
|
|
2008-09-18 07:32:37 +00:00
|
|
|
/*
|
|
|
|
* "diff-files --base -p" should not combine merges because it
|
|
|
|
* was not asked to. "diff-files -c -p" should not densify
|
|
|
|
* (the user should ask with "diff-files --cc" explicitly).
|
|
|
|
*/
|
2020-12-21 15:19:39 +00:00
|
|
|
if (rev.max_count == -1 &&
|
2008-05-24 01:15:03 +00:00
|
|
|
(rev.diffopt.output_format & DIFF_FORMAT_PATCH))
|
2020-12-21 15:19:39 +00:00
|
|
|
diff_merges_set_dense_combined_if_unset(&rev);
|
2008-05-24 01:15:03 +00:00
|
|
|
|
2023-08-21 20:15:10 +00:00
|
|
|
if (repo_read_index_preload(the_repository, &rev.diffopt.pathspec, 0) < 0)
|
|
|
|
die_errno("repo_read_index_preload");
|
diff: drop useless return from run_diff_{files,index} functions
Neither of these functions ever returns a value other than zero.
Instead, they expect unrecoverable errors to exit immediately, and
things like "--exit-code" are stored inside the diff_options struct to
be handled later via diff_result_code().
Some callers do check the return values, but many don't bother. Let's
drop the useless return values, which are misleading callers about how
the functions work. This could be seen as a step in the wrong direction,
as we might want to eventually "lib-ify" these to more cleanly return
errors up the stack, in which case we'd have to add the return values
back in. But there are some benefits to doing this now:
1. In the current code, somebody could accidentally add a "return -1"
to one of the functions, which would be erroneously ignored by many
callers. By removing the return code, the compiler can notice the
mismatch and force the developer to decide what to do.
Obviously the other option here is that we could start consistently
checking the error code in every caller. But it would be dead code,
and we wouldn't get any compile-time help in catching new cases.
2. It communicates the situation to callers, who may want to choose a
different function. These functions are really thin wrappers for
doing git-diff-files and git-diff-index within the process. But
callers who care about recovering from an error here are probably
better off using the underlying library functions, many of
which do return errors.
If somebody eventually wants to teach these functions to propagate
errors, they'll have to switch back to returning a value, effectively
reverting this patch. But at least then they will be starting with a
level playing field: they know that they will need to inspect each
caller to see how it should handle the error.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2023-08-21 20:18:55 +00:00
|
|
|
run_diff_files(&rev, options);
|
2023-08-21 20:20:46 +00:00
|
|
|
result = diff_result_code(&rev.diffopt);
|
2022-04-13 20:01:40 +00:00
|
|
|
release_revisions(&rev);
|
|
|
|
return result;
|
2005-04-07 22:13:13 +00:00
|
|
|
}
|