mirror of
https://github.com/git/git.git
synced 2024-11-24 18:33:43 +08:00
cd1096b282
There are a couple of places where we want to clear the last line on the terminal, e.g. when a progress bar line is overwritten by a shorter line, then the end of that progress line would remain visible, unless we cover it up. In 'progress.c' we did this by always appending a fixed number of space characters to the next line (even if it was not shorter than the previous), but as it turned out that fixed number was not quite large enough, see the fix in9f1fd84e15(progress: clear previous progress update dynamically, 2019-04-12). From then on we've been keeping track of the length of the last displayed progress line and appending the appropriate number of space characters to the next line, if necessary, but, alas, this approach turned out to be error prone, see the fix in1aed1a5f25(progress: avoid empty line when breaking the progress line, 2019-05-19). The next patch in this series is about to fix a case where we don't clear the last line, and on occasion do end up with such garbage at the end of the line. It would be great if we could do that without the need to deal with that without meticulously computing the necessary number of space characters. So add a helper function to clear the last line on the terminal using an ANSI escape sequence, which has the advantage to clear the whole line no matter how wide it is, even after the terminal width changed. Such an escape sequence is not available on dumb terminals, though, so in that case fall back to simply print a whole terminal width (as reported by term_columns()) worth of space characters. In 'editor.c' launch_specified_editor() already used this ANSI escape sequence, so replace it with a call to this function. Signed-off-by: SZEDER Gábor <szeder.dev@gmail.com> Signed-off-by: Junio C Hamano <gitster@pobox.com>
122 lines
2.8 KiB
C
122 lines
2.8 KiB
C
#include "cache.h"
|
|
#include "config.h"
|
|
#include "strbuf.h"
|
|
#include "run-command.h"
|
|
#include "sigchain.h"
|
|
|
|
#ifndef DEFAULT_EDITOR
|
|
#define DEFAULT_EDITOR "vi"
|
|
#endif
|
|
|
|
int is_terminal_dumb(void)
|
|
{
|
|
const char *terminal = getenv("TERM");
|
|
return !terminal || !strcmp(terminal, "dumb");
|
|
}
|
|
|
|
const char *git_editor(void)
|
|
{
|
|
const char *editor = getenv("GIT_EDITOR");
|
|
int terminal_is_dumb = is_terminal_dumb();
|
|
|
|
if (!editor && editor_program)
|
|
editor = editor_program;
|
|
if (!editor && !terminal_is_dumb)
|
|
editor = getenv("VISUAL");
|
|
if (!editor)
|
|
editor = getenv("EDITOR");
|
|
|
|
if (!editor && terminal_is_dumb)
|
|
return NULL;
|
|
|
|
if (!editor)
|
|
editor = DEFAULT_EDITOR;
|
|
|
|
return editor;
|
|
}
|
|
|
|
const char *git_sequence_editor(void)
|
|
{
|
|
const char *editor = getenv("GIT_SEQUENCE_EDITOR");
|
|
|
|
if (!editor)
|
|
git_config_get_string_const("sequence.editor", &editor);
|
|
if (!editor)
|
|
editor = git_editor();
|
|
|
|
return editor;
|
|
}
|
|
|
|
static int launch_specified_editor(const char *editor, const char *path,
|
|
struct strbuf *buffer, const char *const *env)
|
|
{
|
|
if (!editor)
|
|
return error("Terminal is dumb, but EDITOR unset");
|
|
|
|
if (strcmp(editor, ":")) {
|
|
const char *args[] = { editor, real_path(path), NULL };
|
|
struct child_process p = CHILD_PROCESS_INIT;
|
|
int ret, sig;
|
|
int print_waiting_for_editor = advice_waiting_for_editor && isatty(2);
|
|
|
|
if (print_waiting_for_editor) {
|
|
/*
|
|
* A dumb terminal cannot erase the line later on. Add a
|
|
* newline to separate the hint from subsequent output.
|
|
*
|
|
* Make sure that our message is separated with a whitespace
|
|
* from further cruft that may be written by the editor.
|
|
*/
|
|
const char term = is_terminal_dumb() ? '\n' : ' ';
|
|
|
|
fprintf(stderr,
|
|
_("hint: Waiting for your editor to close the file...%c"),
|
|
term);
|
|
fflush(stderr);
|
|
}
|
|
|
|
p.argv = args;
|
|
p.env = env;
|
|
p.use_shell = 1;
|
|
p.trace2_child_class = "editor";
|
|
if (start_command(&p) < 0)
|
|
return error("unable to start editor '%s'", editor);
|
|
|
|
sigchain_push(SIGINT, SIG_IGN);
|
|
sigchain_push(SIGQUIT, SIG_IGN);
|
|
ret = finish_command(&p);
|
|
sig = ret - 128;
|
|
sigchain_pop(SIGINT);
|
|
sigchain_pop(SIGQUIT);
|
|
if (sig == SIGINT || sig == SIGQUIT)
|
|
raise(sig);
|
|
if (ret)
|
|
return error("There was a problem with the editor '%s'.",
|
|
editor);
|
|
|
|
if (print_waiting_for_editor && !is_terminal_dumb())
|
|
/*
|
|
* Erase the entire line to avoid wasting the
|
|
* vertical space.
|
|
*/
|
|
term_clear_line();
|
|
}
|
|
|
|
if (!buffer)
|
|
return 0;
|
|
if (strbuf_read_file(buffer, path, 0) < 0)
|
|
return error_errno("could not read file '%s'", path);
|
|
return 0;
|
|
}
|
|
|
|
int launch_editor(const char *path, struct strbuf *buffer, const char *const *env)
|
|
{
|
|
return launch_specified_editor(git_editor(), path, buffer, env);
|
|
}
|
|
|
|
int launch_sequence_editor(const char *path, struct strbuf *buffer,
|
|
const char *const *env)
|
|
{
|
|
return launch_specified_editor(git_sequence_editor(), path, buffer, env);
|
|
}
|