-/*
- * builtin-help.c
- *
- * Builtin help-related commands (help, usage, version)
- */
#include "cache.h"
+#include "config.h"
#include "builtin.h"
-#include "exec_cmd.h"
-#include "common-cmds.h"
-#include "parse-options.h"
+#include "exec-cmd.h"
#include "run-command.h"
+#include "levenshtein.h"
+#include "help.h"
+#include "command-list.h"
+#include "string-list.h"
+#include "column.h"
+#include "version.h"
+#include "refs.h"
+#include "parse-options.h"
-static struct man_viewer_list {
- struct man_viewer_list *next;
- char name[FLEX_ARRAY];
-} *man_viewer_list;
-
-static struct man_viewer_info_list {
- struct man_viewer_info_list *next;
- const char *info;
- char name[FLEX_ARRAY];
-} *man_viewer_info_list;
-
-enum help_format {
- HELP_FORMAT_MAN,
- HELP_FORMAT_INFO,
- HELP_FORMAT_WEB,
+struct category_description {
+ uint32_t category;
+ const char *desc;
};
-
-static int show_all = 0;
-static enum help_format help_format = HELP_FORMAT_MAN;
-static struct option builtin_help_options[] = {
- OPT_BOOLEAN('a', "all", &show_all, "print all available commands"),
- OPT_SET_INT('m', "man", &help_format, "show man page", HELP_FORMAT_MAN),
- OPT_SET_INT('w', "web", &help_format, "show manual in web browser",
- HELP_FORMAT_WEB),
- OPT_SET_INT('i', "info", &help_format, "show info page",
- HELP_FORMAT_INFO),
- OPT_END(),
+static uint32_t common_mask =
+ CAT_init | CAT_worktree | CAT_info |
+ CAT_history | CAT_remote;
+static struct category_description common_categories[] = {
+ { CAT_init, N_("start a working area (see also: git help tutorial)") },
+ { CAT_worktree, N_("work on the current change (see also: git help everyday)") },
+ { CAT_info, N_("examine the history and state (see also: git help revisions)") },
+ { CAT_history, N_("grow, mark and tweak your common history") },
+ { CAT_remote, N_("collaborate (see also: git help workflows)") },
+ { 0, NULL }
};
-
-static const char * const builtin_help_usage[] = {
- "git help [--all] [--man|--web|--info] [command]",
- NULL
+static struct category_description main_categories[] = {
+ { CAT_mainporcelain, N_("Main Porcelain Commands") },
+ { CAT_ancillarymanipulators, N_("Ancillary Commands / Manipulators") },
+ { CAT_ancillaryinterrogators, N_("Ancillary Commands / Interrogators") },
+ { CAT_foreignscminterface, N_("Interacting with Others") },
+ { CAT_plumbingmanipulators, N_("Low-level Commands / Manipulators") },
+ { CAT_plumbinginterrogators, N_("Low-level Commands / Interrogators") },
+ { CAT_synchingrepositories, N_("Low-level Commands / Synching Repositories") },
+ { CAT_purehelpers, N_("Low-level Commands / Internal Helpers") },
+ { 0, NULL }
};
-static enum help_format parse_help_format(const char *format)
+static const char *drop_prefix(const char *name, uint32_t category)
{
- if (!strcmp(format, "man"))
- return HELP_FORMAT_MAN;
- if (!strcmp(format, "info"))
- return HELP_FORMAT_INFO;
- if (!strcmp(format, "web") || !strcmp(format, "html"))
- return HELP_FORMAT_WEB;
- die("unrecognized help format '%s'", format);
-}
+ const char *new_name;
-static const char *get_man_viewer_info(const char *name)
-{
- struct man_viewer_info_list *viewer;
+ if (skip_prefix(name, "git-", &new_name))
+ return new_name;
+ if (category == CAT_guide && skip_prefix(name, "git", &new_name))
+ return new_name;
+ return name;
- for (viewer = man_viewer_info_list; viewer; viewer = viewer->next)
- {
- if (!strcasecmp(name, viewer->name))
- return viewer->info;
- }
- return NULL;
}
-static int check_emacsclient_version(void)
+static void extract_cmds(struct cmdname_help **p_cmds, uint32_t mask)
{
- struct strbuf buffer = STRBUF_INIT;
- struct child_process ec_process;
- const char *argv_ec[] = { "emacsclient", "--version", NULL };
- int version;
+ int i, nr = 0;
+ struct cmdname_help *cmds;
- /* emacsclient prints its version number on stderr */
- memset(&ec_process, 0, sizeof(ec_process));
- ec_process.argv = argv_ec;
- ec_process.err = -1;
- ec_process.stdout_to_stderr = 1;
- if (start_command(&ec_process)) {
- fprintf(stderr, "Failed to start emacsclient.\n");
- return -1;
- }
- strbuf_read(&buffer, ec_process.err, 20);
- close(ec_process.err);
-
- /*
- * Don't bother checking return value, because "emacsclient --version"
- * seems to always exits with code 1.
- */
- finish_command(&ec_process);
-
- if (prefixcmp(buffer.buf, "emacsclient")) {
- fprintf(stderr, "Failed to parse emacsclient version.\n");
- strbuf_release(&buffer);
- return -1;
- }
+ if (ARRAY_SIZE(command_list) == 0)
+ BUG("empty command_list[] is a sign of broken generate-cmdlist.sh");
- strbuf_remove(&buffer, 0, strlen("emacsclient"));
- version = atoi(buffer.buf);
+ ALLOC_ARRAY(cmds, ARRAY_SIZE(command_list) + 1);
- if (version < 22) {
- fprintf(stderr,
- "emacsclient version '%d' too old (< 22).\n",
- version);
- strbuf_release(&buffer);
- return -1;
- }
+ for (i = 0; i < ARRAY_SIZE(command_list); i++) {
+ const struct cmdname_help *cmd = command_list + i;
- strbuf_release(&buffer);
- return 0;
-}
+ if (!(cmd->category & mask))
+ continue;
-static void exec_woman_emacs(const char* path, const char *page)
-{
- if (!check_emacsclient_version()) {
- /* This works only with emacsclient version >= 22. */
- struct strbuf man_page = STRBUF_INIT;
+ cmds[nr] = *cmd;
+ cmds[nr].name = drop_prefix(cmd->name, cmd->category);
- if (!path)
- path = "emacsclient";
- strbuf_addf(&man_page, "(woman \"%s\")", page);
- execlp(path, "emacsclient", "-e", man_page.buf, NULL);
- warning("failed to exec '%s': %s", path, strerror(errno));
+ nr++;
}
+ cmds[nr].name = NULL;
+ *p_cmds = cmds;
}
-static void exec_man_konqueror(const char* path, const char *page)
+static void print_command_list(const struct cmdname_help *cmds,
+ uint32_t mask, int longest)
{
- const char *display = getenv("DISPLAY");
- if (display && *display) {
- struct strbuf man_page = STRBUF_INIT;
- const char *filename = "kfmclient";
-
- /* It's simpler to launch konqueror using kfmclient. */
- if (path) {
- const char *file = strrchr(path, '/');
- if (file && !strcmp(file + 1, "konqueror")) {
- char *new = xstrdup(path);
- char *dest = strrchr(new, '/');
+ int i;
- /* strlen("konqueror") == strlen("kfmclient") */
- strcpy(dest + 1, "kfmclient");
- path = new;
- }
- if (file)
- filename = file;
- } else
- path = "kfmclient";
- strbuf_addf(&man_page, "man:%s(1)", page);
- execlp(path, filename, "newTab", man_page.buf, NULL);
- warning("failed to exec '%s': %s", path, strerror(errno));
+ for (i = 0; cmds[i].name; i++) {
+ if (cmds[i].category & mask) {
+ size_t len = strlen(cmds[i].name);
+ printf(" %s ", cmds[i].name);
+ if (longest > len)
+ mput_char(' ', longest - len);
+ puts(_(cmds[i].help));
+ }
}
}
-static void exec_man_man(const char* path, const char *page)
+static int cmd_name_cmp(const void *elem1, const void *elem2)
{
- if (!path)
- path = "man";
- execlp(path, "man", page, NULL);
- warning("failed to exec '%s': %s", path, strerror(errno));
-}
+ const struct cmdname_help *e1 = elem1;
+ const struct cmdname_help *e2 = elem2;
-static void exec_man_cmd(const char *cmd, const char *page)
-{
- struct strbuf shell_cmd = STRBUF_INIT;
- strbuf_addf(&shell_cmd, "%s %s", cmd, page);
- execl("/bin/sh", "sh", "-c", shell_cmd.buf, NULL);
- warning("failed to exec '%s': %s", cmd, strerror(errno));
+ return strcmp(e1->name, e2->name);
}
-static void add_man_viewer(const char *name)
+static void print_cmd_by_category(const struct category_description *catdesc,
+ int *longest_p)
{
- struct man_viewer_list **p = &man_viewer_list;
- size_t len = strlen(name);
+ struct cmdname_help *cmds;
+ int longest = 0;
+ int i, nr = 0;
+ uint32_t mask = 0;
- while (*p)
- p = &((*p)->next);
- *p = xcalloc(1, (sizeof(**p) + len + 1));
- strncpy((*p)->name, name, len);
-}
+ for (i = 0; catdesc[i].desc; i++)
+ mask |= catdesc[i].category;
-static int supported_man_viewer(const char *name, size_t len)
-{
- return (!strncasecmp("man", name, len) ||
- !strncasecmp("woman", name, len) ||
- !strncasecmp("konqueror", name, len));
-}
-
-static void do_add_man_viewer_info(const char *name,
- size_t len,
- const char *value)
-{
- struct man_viewer_info_list *new = xcalloc(1, sizeof(*new) + len + 1);
-
- strncpy(new->name, name, len);
- new->info = xstrdup(value);
- new->next = man_viewer_info_list;
- man_viewer_info_list = new;
-}
-
-static int add_man_viewer_path(const char *name,
- size_t len,
- const char *value)
-{
- if (supported_man_viewer(name, len))
- do_add_man_viewer_info(name, len, value);
- else
- warning("'%s': path for unsupported man viewer.\n"
- "Please consider using 'man.<tool>.cmd' instead.",
- name);
+ extract_cmds(&cmds, mask);
- return 0;
-}
-
-static int add_man_viewer_cmd(const char *name,
- size_t len,
- const char *value)
-{
- if (supported_man_viewer(name, len))
- warning("'%s': cmd for supported man viewer.\n"
- "Please consider using 'man.<tool>.path' instead.",
- name);
- else
- do_add_man_viewer_info(name, len, value);
-
- return 0;
-}
-
-static int add_man_viewer_info(const char *var, const char *value)
-{
- const char *name = var + 4;
- const char *subkey = strrchr(name, '.');
-
- if (!subkey)
- return error("Config with no key for man viewer: %s", name);
-
- if (!strcmp(subkey, ".path")) {
- if (!value)
- return config_error_nonbool(var);
- return add_man_viewer_path(name, subkey - name, value);
- }
- if (!strcmp(subkey, ".cmd")) {
- if (!value)
- return config_error_nonbool(var);
- return add_man_viewer_cmd(name, subkey - name, value);
- }
-
- warning("'%s': unsupported man viewer sub key.", subkey);
- return 0;
-}
-
-static int git_help_config(const char *var, const char *value, void *cb)
-{
- if (!strcmp(var, "help.format")) {
- if (!value)
- return config_error_nonbool(var);
- help_format = parse_help_format(value);
- return 0;
+ for (i = 0; cmds[i].name; i++, nr++) {
+ if (longest < strlen(cmds[i].name))
+ longest = strlen(cmds[i].name);
}
- if (!strcmp(var, "man.viewer")) {
- if (!value)
- return config_error_nonbool(var);
- add_man_viewer(value);
- return 0;
- }
- if (!prefixcmp(var, "man."))
- return add_man_viewer_info(var, value);
+ QSORT(cmds, nr, cmd_name_cmp);
- return git_default_config(var, value, cb);
-}
+ for (i = 0; catdesc[i].desc; i++) {
+ uint32_t mask = catdesc[i].category;
+ const char *desc = catdesc[i].desc;
-/* most GUI terminals set COLUMNS (although some don't export it) */
-static int term_columns(void)
-{
- char *col_string = getenv("COLUMNS");
- int n_cols;
-
- if (col_string && (n_cols = atoi(col_string)) > 0)
- return n_cols;
-
-#ifdef TIOCGWINSZ
- {
- struct winsize ws;
- if (!ioctl(1, TIOCGWINSZ, &ws)) {
- if (ws.ws_col)
- return ws.ws_col;
- }
+ printf("\n%s\n", _(desc));
+ print_command_list(cmds, mask, longest);
}
-#endif
-
- return 80;
-}
-
-static inline void mput_char(char c, unsigned int num)
-{
- while(num--)
- putchar(c);
+ free(cmds);
+ if (longest_p)
+ *longest_p = longest;
}
-static struct cmdnames {
- int alloc;
- int cnt;
- struct cmdname {
- size_t len;
- char name[1];
- } **names;
-} main_cmds, other_cmds;
-
-static void add_cmdname(struct cmdnames *cmds, const char *name, int len)
+void add_cmdname(struct cmdnames *cmds, const char *name, int len)
{
- struct cmdname *ent = xmalloc(sizeof(*ent) + len);
-
+ struct cmdname *ent;
+ FLEX_ALLOC_MEM(ent, name, name, len);
ent->len = len;
- memcpy(ent->name, name, len);
- ent->name[len] = 0;
ALLOC_GROW(cmds->names, cmds->cnt + 1, cmds->alloc);
cmds->names[cmds->cnt++] = ent;
}
+static void clean_cmdnames(struct cmdnames *cmds)
+{
+ int i;
+ for (i = 0; i < cmds->cnt; ++i)
+ free(cmds->names[i]);
+ free(cmds->names);
+ cmds->cnt = 0;
+ cmds->alloc = 0;
+}
+
static int cmdname_compare(const void *a_, const void *b_)
{
struct cmdname *a = *(struct cmdname **)a_;
if (!cmds->cnt)
return;
- for (i = j = 1; i < cmds->cnt; i++)
- if (strcmp(cmds->names[i]->name, cmds->names[i-1]->name))
+ for (i = j = 1; i < cmds->cnt; i++) {
+ if (!strcmp(cmds->names[i]->name, cmds->names[j-1]->name))
+ free(cmds->names[i]);
+ else
cmds->names[j++] = cmds->names[i];
+ }
cmds->cnt = j;
}
-static void exclude_cmds(struct cmdnames *cmds, struct cmdnames *excludes)
+void exclude_cmds(struct cmdnames *cmds, struct cmdnames *excludes)
{
int ci, cj, ei;
int cmp;
cmp = strcmp(cmds->names[ci]->name, excludes->names[ei]->name);
if (cmp < 0)
cmds->names[cj++] = cmds->names[ci++];
- else if (cmp == 0)
- ci++, ei++;
- else if (cmp > 0)
+ else if (cmp == 0) {
+ ei++;
+ free(cmds->names[ci++]);
+ } else if (cmp > 0)
ei++;
}
cmds->cnt = cj;
}
-static void pretty_print_string_list(struct cmdnames *cmds, int longest)
+static void pretty_print_cmdnames(struct cmdnames *cmds, unsigned int colopts)
{
- int cols = 1, rows;
- int space = longest + 1; /* min 1 SP between words */
- int max_cols = term_columns() - 1; /* don't print *on* the edge */
- int i, j;
-
- if (space < max_cols)
- cols = max_cols / space;
- rows = (cmds->cnt + cols - 1) / cols;
-
- for (i = 0; i < rows; i++) {
- printf(" ");
-
- for (j = 0; j < cols; j++) {
- int n = j * rows + i;
- int size = space;
- if (n >= cmds->cnt)
- break;
- if (j == cols-1 || n + rows >= cmds->cnt)
- size = 1;
- printf("%-*s", size, cmds->names[n]->name);
- }
- putchar('\n');
- }
-}
-
-static int is_executable(const char *name)
-{
- struct stat st;
-
- if (stat(name, &st) || /* stat, not lstat */
- !S_ISREG(st.st_mode))
- return 0;
+ struct string_list list = STRING_LIST_INIT_NODUP;
+ struct column_options copts;
+ int i;
-#ifdef __MINGW32__
- /* cannot trust the executable bit, peek into the file instead */
- char buf[3] = { 0 };
- int n;
- int fd = open(name, O_RDONLY);
- st.st_mode &= ~S_IXUSR;
- if (fd >= 0) {
- n = read(fd, buf, 2);
- if (n == 2)
- /* DOS executables start with "MZ" */
- if (!strcmp(buf, "#!") || !strcmp(buf, "MZ"))
- st.st_mode |= S_IXUSR;
- close(fd);
- }
-#endif
- return st.st_mode & S_IXUSR;
+ for (i = 0; i < cmds->cnt; i++)
+ string_list_append(&list, cmds->names[i]->name);
+ /*
+ * always enable column display, we only consult column.*
+ * about layout strategy and stuff
+ */
+ colopts = (colopts & ~COL_ENABLE_MASK) | COL_ENABLED;
+ memset(&copts, 0, sizeof(copts));
+ copts.indent = " ";
+ copts.padding = 2;
+ print_columns(&list, colopts, &copts);
+ string_list_clear(&list, 0);
}
-static unsigned int list_commands_in_dir(struct cmdnames *cmds,
- const char *path)
+static void list_commands_in_dir(struct cmdnames *cmds,
+ const char *path,
+ const char *prefix)
{
- unsigned int longest = 0;
- const char *prefix = "git-";
- int prefix_len = strlen(prefix);
DIR *dir = opendir(path);
struct dirent *de;
struct strbuf buf = STRBUF_INIT;
int len;
if (!dir)
- return 0;
+ return;
+ if (!prefix)
+ prefix = "git-";
strbuf_addf(&buf, "%s/", path);
len = buf.len;
while ((de = readdir(dir)) != NULL) {
- int entlen;
+ const char *ent;
+ size_t entlen;
- if (prefixcmp(de->d_name, prefix))
+ if (!skip_prefix(de->d_name, prefix, &ent))
continue;
strbuf_setlen(&buf, len);
if (!is_executable(buf.buf))
continue;
- entlen = strlen(de->d_name) - prefix_len;
- if (has_extension(de->d_name, ".exe"))
- entlen -= 4;
+ entlen = strlen(ent);
+ strip_suffix(ent, ".exe", &entlen);
- if (longest < entlen)
- longest = entlen;
-
- add_cmdname(cmds, de->d_name + prefix_len, entlen);
+ add_cmdname(cmds, ent, entlen);
}
closedir(dir);
strbuf_release(&buf);
-
- return longest;
}
-static unsigned int load_command_list(void)
+void load_command_list(const char *prefix,
+ struct cmdnames *main_cmds,
+ struct cmdnames *other_cmds)
{
- unsigned int longest = 0;
- unsigned int len;
const char *env_path = getenv("PATH");
- char *paths, *path, *colon;
const char *exec_path = git_exec_path();
- if (exec_path)
- longest = list_commands_in_dir(&main_cmds, exec_path);
-
- if (!env_path) {
- fprintf(stderr, "PATH not set\n");
- exit(1);
+ if (exec_path) {
+ list_commands_in_dir(main_cmds, exec_path, prefix);
+ QSORT(main_cmds->names, main_cmds->cnt, cmdname_compare);
+ uniq(main_cmds);
}
- path = paths = xstrdup(env_path);
- while (1) {
- if ((colon = strchr(path, PATH_SEP)))
- *colon = 0;
+ if (env_path) {
+ char *paths, *path, *colon;
+ path = paths = xstrdup(env_path);
+ while (1) {
+ if ((colon = strchr(path, PATH_SEP)))
+ *colon = 0;
+ if (!exec_path || strcmp(path, exec_path))
+ list_commands_in_dir(other_cmds, path, prefix);
- len = list_commands_in_dir(&other_cmds, path);
- if (len > longest)
- longest = len;
+ if (!colon)
+ break;
+ path = colon + 1;
+ }
+ free(paths);
- if (!colon)
- break;
- path = colon + 1;
+ QSORT(other_cmds->names, other_cmds->cnt, cmdname_compare);
+ uniq(other_cmds);
}
- free(paths);
-
- qsort(main_cmds.names, main_cmds.cnt,
- sizeof(*main_cmds.names), cmdname_compare);
- uniq(&main_cmds);
-
- qsort(other_cmds.names, other_cmds.cnt,
- sizeof(*other_cmds.names), cmdname_compare);
- uniq(&other_cmds);
- exclude_cmds(&other_cmds, &main_cmds);
-
- return longest;
+ exclude_cmds(other_cmds, main_cmds);
}
-static void list_commands(void)
+void list_commands(unsigned int colopts,
+ struct cmdnames *main_cmds, struct cmdnames *other_cmds)
{
- unsigned int longest = load_command_list();
- const char *exec_path = git_exec_path();
-
- if (main_cmds.cnt) {
- printf("available git commands in '%s'\n", exec_path);
- printf("----------------------------");
- mput_char('-', strlen(exec_path));
+ if (main_cmds->cnt) {
+ const char *exec_path = git_exec_path();
+ printf_ln(_("available git commands in '%s'"), exec_path);
putchar('\n');
- pretty_print_string_list(&main_cmds, longest);
+ pretty_print_cmdnames(main_cmds, colopts);
putchar('\n');
}
- if (other_cmds.cnt) {
- printf("git commands available from elsewhere on your $PATH\n");
- printf("---------------------------------------------------\n");
- pretty_print_string_list(&other_cmds, longest);
+ if (other_cmds->cnt) {
+ printf_ln(_("git commands available from elsewhere on your $PATH"));
+ putchar('\n');
+ pretty_print_cmdnames(other_cmds, colopts);
putchar('\n');
}
}
void list_common_cmds_help(void)
{
- int i, longest = 0;
+ puts(_("These are common Git commands used in various situations:"));
+ print_cmd_by_category(common_categories, NULL);
+}
+
+void list_all_main_cmds(struct string_list *list)
+{
+ struct cmdnames main_cmds, other_cmds;
+ int i;
- for (i = 0; i < ARRAY_SIZE(common_cmds); i++) {
- if (longest < strlen(common_cmds[i].name))
- longest = strlen(common_cmds[i].name);
- }
+ memset(&main_cmds, 0, sizeof(main_cmds));
+ memset(&other_cmds, 0, sizeof(other_cmds));
+ load_command_list("git-", &main_cmds, &other_cmds);
- puts("The most commonly used git commands are:");
- for (i = 0; i < ARRAY_SIZE(common_cmds); i++) {
- printf(" %s ", common_cmds[i].name);
- mput_char(' ', longest - strlen(common_cmds[i].name));
- puts(common_cmds[i].help);
- }
+ for (i = 0; i < main_cmds.cnt; i++)
+ string_list_append(list, main_cmds.names[i]->name);
+
+ clean_cmdnames(&main_cmds);
+ clean_cmdnames(&other_cmds);
}
-static int is_in_cmdlist(struct cmdnames *c, const char *s)
+void list_all_other_cmds(struct string_list *list)
{
+ struct cmdnames main_cmds, other_cmds;
int i;
- for (i = 0; i < c->cnt; i++)
- if (!strcmp(s, c->names[i]->name))
- return 1;
- return 0;
+
+ memset(&main_cmds, 0, sizeof(main_cmds));
+ memset(&other_cmds, 0, sizeof(other_cmds));
+ load_command_list("git-", &main_cmds, &other_cmds);
+
+ for (i = 0; i < other_cmds.cnt; i++)
+ string_list_append(list, other_cmds.names[i]->name);
+
+ clean_cmdnames(&main_cmds);
+ clean_cmdnames(&other_cmds);
}
-static int is_git_command(const char *s)
+void list_cmds_by_category(struct string_list *list,
+ const char *cat)
{
- load_command_list();
- return is_in_cmdlist(&main_cmds, s) ||
- is_in_cmdlist(&other_cmds, s);
+ int i, n = ARRAY_SIZE(command_list);
+ uint32_t cat_id = 0;
+
+ for (i = 0; category_names[i]; i++) {
+ if (!strcmp(cat, category_names[i])) {
+ cat_id = 1UL << i;
+ break;
+ }
+ }
+ if (!cat_id)
+ die(_("unsupported command listing type '%s'"), cat);
+
+ for (i = 0; i < n; i++) {
+ struct cmdname_help *cmd = command_list + i;
+
+ if (!(cmd->category & cat_id))
+ continue;
+ string_list_append(list, drop_prefix(cmd->name, cmd->category));
+ }
}
-static const char *prepend(const char *prefix, const char *cmd)
+void list_cmds_by_config(struct string_list *list)
{
- size_t pre_len = strlen(prefix);
- size_t cmd_len = strlen(cmd);
- char *p = xmalloc(pre_len + cmd_len + 1);
- memcpy(p, prefix, pre_len);
- strcpy(p + pre_len, cmd);
- return p;
+ const char *cmd_list;
+
+ /*
+ * There's no actual repository setup at this point (and even
+ * if there is, we don't really care; only global config
+ * matters). If we accidentally set up a repository, it's ok
+ * too since the caller (git --list-cmds=) should exit shortly
+ * anyway.
+ */
+ if (git_config_get_string_const("completion.commands", &cmd_list))
+ return;
+
+ string_list_sort(list);
+ string_list_remove_duplicates(list, 0);
+
+ while (*cmd_list) {
+ struct strbuf sb = STRBUF_INIT;
+ const char *p = strchrnul(cmd_list, ' ');
+
+ strbuf_add(&sb, cmd_list, p - cmd_list);
+ if (*cmd_list == '-')
+ string_list_remove(list, cmd_list + 1, 0);
+ else
+ string_list_insert(list, sb.buf);
+ strbuf_release(&sb);
+ while (*p == ' ')
+ p++;
+ cmd_list = p;
+ }
}
-static const char *cmd_to_page(const char *git_cmd)
+void list_common_guides_help(void)
{
- if (!git_cmd)
- return "git";
- else if (!prefixcmp(git_cmd, "git"))
- return git_cmd;
- else if (is_git_command(git_cmd))
- return prepend("git-", git_cmd);
- else
- return prepend("git", git_cmd);
+ struct category_description catdesc[] = {
+ { CAT_guide, N_("The common Git guides are:") },
+ { 0, NULL }
+ };
+ print_cmd_by_category(catdesc, NULL);
+ putchar('\n');
}
-static void setup_man_path(void)
-{
- struct strbuf new_path;
- const char *old_path = getenv("MANPATH");
+struct slot_expansion {
+ const char *prefix;
+ const char *placeholder;
+ void (*fn)(struct string_list *list, const char *prefix);
+ int found;
+};
- strbuf_init(&new_path, 0);
+void list_config_help(int for_human)
+{
+ struct slot_expansion slot_expansions[] = {
+ { "advice", "*", list_config_advices },
+ { "color.branch", "<slot>", list_config_color_branch_slots },
+ { "color.decorate", "<slot>", list_config_color_decorate_slots },
+ { "color.diff", "<slot>", list_config_color_diff_slots },
+ { "color.grep", "<slot>", list_config_color_grep_slots },
+ { "color.interactive", "<slot>", list_config_color_interactive_slots },
+ { "color.remote", "<slot>", list_config_color_sideband_slots },
+ { "color.status", "<slot>", list_config_color_status_slots },
+ { "fsck", "<msg-id>", list_config_fsck_msg_ids },
+ { "receive.fsck", "<msg-id>", list_config_fsck_msg_ids },
+ { NULL, NULL, NULL }
+ };
+ const char **p;
+ struct slot_expansion *e;
+ struct string_list keys = STRING_LIST_INIT_DUP;
+ int i;
- /* We should always put ':' after our path. If there is no
- * old_path, the ':' at the end will let 'man' to try
- * system-wide paths after ours to find the manual page. If
- * there is old_path, we need ':' as delimiter. */
- strbuf_addstr(&new_path, GIT_MAN_PATH);
- strbuf_addch(&new_path, ':');
- if (old_path)
- strbuf_addstr(&new_path, old_path);
+ for (p = config_name_list; *p; p++) {
+ const char *var = *p;
+ struct strbuf sb = STRBUF_INIT;
- setenv("MANPATH", new_path.buf, 1);
+ for (e = slot_expansions; e->prefix; e++) {
- strbuf_release(&new_path);
+ strbuf_reset(&sb);
+ strbuf_addf(&sb, "%s.%s", e->prefix, e->placeholder);
+ if (!strcasecmp(var, sb.buf)) {
+ e->fn(&keys, e->prefix);
+ e->found++;
+ break;
+ }
+ }
+ strbuf_release(&sb);
+ if (!e->prefix)
+ string_list_append(&keys, var);
+ }
+
+ for (e = slot_expansions; e->prefix; e++)
+ if (!e->found)
+ BUG("slot_expansion %s.%s is not used",
+ e->prefix, e->placeholder);
+
+ string_list_sort(&keys);
+ for (i = 0; i < keys.nr; i++) {
+ const char *var = keys.items[i].string;
+ const char *wildcard, *tag, *cut;
+
+ if (for_human) {
+ puts(var);
+ continue;
+ }
+
+ wildcard = strchr(var, '*');
+ tag = strchr(var, '<');
+
+ if (!wildcard && !tag) {
+ puts(var);
+ continue;
+ }
+
+ if (wildcard && !tag)
+ cut = wildcard;
+ else if (!wildcard && tag)
+ cut = tag;
+ else
+ cut = wildcard < tag ? wildcard : tag;
+
+ /*
+ * We may produce duplicates, but that's up to
+ * git-completion.bash to handle
+ */
+ printf("%.*s\n", (int)(cut - var), var);
+ }
+ string_list_clear(&keys, 0);
}
-static void exec_viewer(const char *name, const char *page)
+static int get_alias(const char *var, const char *value, void *data)
{
- const char *info = get_man_viewer_info(name);
+ struct string_list *list = data;
- if (!strcasecmp(name, "man"))
- exec_man_man(info, page);
- else if (!strcasecmp(name, "woman"))
- exec_woman_emacs(info, page);
- else if (!strcasecmp(name, "konqueror"))
- exec_man_konqueror(info, page);
- else if (info)
- exec_man_cmd(info, page);
- else
- warning("'%s': unknown man viewer.", name);
+ if (skip_prefix(var, "alias.", &var))
+ string_list_append(list, var)->util = xstrdup(value);
+
+ return 0;
}
-static void show_man_page(const char *git_cmd)
+void list_all_cmds_help(void)
{
- struct man_viewer_list *viewer;
- const char *page = cmd_to_page(git_cmd);
+ struct string_list others = STRING_LIST_INIT_DUP;
+ struct string_list alias_list = STRING_LIST_INIT_DUP;
+ struct cmdname_help *aliases;
+ int i, longest;
+
+ printf_ln(_("See 'git help <command>' to read about a specific subcommand"));
+ print_cmd_by_category(main_categories, &longest);
+
+ list_all_other_cmds(&others);
+ if (others.nr)
+ printf("\n%s\n", _("External commands"));
+ for (i = 0; i < others.nr; i++)
+ printf(" %s\n", others.items[i].string);
+ string_list_clear(&others, 0);
+
+ git_config(get_alias, &alias_list);
+ string_list_sort(&alias_list);
+
+ for (i = 0; i < alias_list.nr; i++) {
+ size_t len = strlen(alias_list.items[i].string);
+ if (longest < len)
+ longest = len;
+ }
- setup_man_path();
- for (viewer = man_viewer_list; viewer; viewer = viewer->next)
- {
- exec_viewer(viewer->name, page); /* will return when unable */
+ if (alias_list.nr) {
+ printf("\n%s\n", _("Command aliases"));
+ ALLOC_ARRAY(aliases, alias_list.nr + 1);
+ for (i = 0; i < alias_list.nr; i++) {
+ aliases[i].name = alias_list.items[i].string;
+ aliases[i].help = alias_list.items[i].util;
+ aliases[i].category = 1;
+ }
+ aliases[alias_list.nr].name = NULL;
+ print_command_list(aliases, 1, longest);
+ free(aliases);
}
- exec_viewer("man", page);
- die("no man viewer handled the request");
+ string_list_clear(&alias_list, 1);
}
-static void show_info_page(const char *git_cmd)
+int is_in_cmdlist(struct cmdnames *c, const char *s)
{
- const char *page = cmd_to_page(git_cmd);
- setenv("INFOPATH", GIT_INFO_PATH, 1);
- execlp("info", "info", "gitman", page, NULL);
+ int i;
+ for (i = 0; i < c->cnt; i++)
+ if (!strcmp(s, c->names[i]->name))
+ return 1;
+ return 0;
}
-static void get_html_page_path(struct strbuf *page_path, const char *page)
+static int autocorrect;
+static struct cmdnames aliases;
+
+static int git_unknown_cmd_config(const char *var, const char *value, void *cb)
{
- struct stat st;
- const char *html_path = system_path(GIT_HTML_PATH);
+ const char *p;
- /* Check that we have a git documentation directory. */
- if (stat(mkpath("%s/git.html", html_path), &st)
- || !S_ISREG(st.st_mode))
- die("'%s': not a documentation directory.", html_path);
+ if (!strcmp(var, "help.autocorrect"))
+ autocorrect = git_config_int(var,value);
+ /* Also use aliases for command lookup */
+ if (skip_prefix(var, "alias.", &p))
+ add_cmdname(&aliases, p, strlen(p));
- strbuf_init(page_path, 0);
- strbuf_addf(page_path, "%s/%s.html", html_path, page);
+ return git_default_config(var, value, cb);
}
-/*
- * If open_html is not defined in a platform-specific way (see for
- * example compat/mingw.h), we use the script web--browse to display
- * HTML.
- */
-#ifndef open_html
-void open_html(const char *path)
+static int levenshtein_compare(const void *p1, const void *p2)
{
- execl_git_cmd("web--browse", "-c", "help.browser", path, NULL);
+ const struct cmdname *const *c1 = p1, *const *c2 = p2;
+ const char *s1 = (*c1)->name, *s2 = (*c2)->name;
+ int l1 = (*c1)->len;
+ int l2 = (*c2)->len;
+ return l1 != l2 ? l1 - l2 : strcmp(s1, s2);
}
-#endif
-static void show_html_page(const char *git_cmd)
+static void add_cmd_list(struct cmdnames *cmds, struct cmdnames *old)
{
- const char *page = cmd_to_page(git_cmd);
- struct strbuf page_path; /* it leaks but we exec bellow */
-
- get_html_page_path(&page_path, page);
+ int i;
+ ALLOC_GROW(cmds->names, cmds->cnt + old->cnt, cmds->alloc);
- open_html(page_path.buf);
+ for (i = 0; i < old->cnt; i++)
+ cmds->names[cmds->cnt++] = old->names[i];
+ FREE_AND_NULL(old->names);
+ old->cnt = 0;
}
-void help_unknown_cmd(const char *cmd)
+/* An empirically derived magic number */
+#define SIMILARITY_FLOOR 7
+#define SIMILAR_ENOUGH(x) ((x) < SIMILARITY_FLOOR)
+
+static const char bad_interpreter_advice[] =
+ N_("'%s' appears to be a git command, but we were not\n"
+ "able to execute it. Maybe git-%s is broken?");
+
+const char *help_unknown_cmd(const char *cmd)
{
- fprintf(stderr, "git: '%s' is not a git-command. See 'git --help'.\n", cmd);
+ int i, n, best_similarity = 0;
+ struct cmdnames main_cmds, other_cmds;
+ struct cmdname_help *common_cmds;
+
+ memset(&main_cmds, 0, sizeof(main_cmds));
+ memset(&other_cmds, 0, sizeof(other_cmds));
+ memset(&aliases, 0, sizeof(aliases));
+
+ read_early_config(git_unknown_cmd_config, NULL);
+
+ load_command_list("git-", &main_cmds, &other_cmds);
+
+ add_cmd_list(&main_cmds, &aliases);
+ add_cmd_list(&main_cmds, &other_cmds);
+ QSORT(main_cmds.names, main_cmds.cnt, cmdname_compare);
+ uniq(&main_cmds);
+
+ extract_cmds(&common_cmds, common_mask);
+
+ /* This abuses cmdname->len for levenshtein distance */
+ for (i = 0, n = 0; i < main_cmds.cnt; i++) {
+ int cmp = 0; /* avoid compiler stupidity */
+ const char *candidate = main_cmds.names[i]->name;
+
+ /*
+ * An exact match means we have the command, but
+ * for some reason exec'ing it gave us ENOENT; probably
+ * it's a bad interpreter in the #! line.
+ */
+ if (!strcmp(candidate, cmd))
+ die(_(bad_interpreter_advice), cmd, cmd);
+
+ /* Does the candidate appear in common_cmds list? */
+ while (common_cmds[n].name &&
+ (cmp = strcmp(common_cmds[n].name, candidate)) < 0)
+ n++;
+ if (common_cmds[n].name && !cmp) {
+ /* Yes, this is one of the common commands */
+ n++; /* use the entry from common_cmds[] */
+ if (starts_with(candidate, cmd)) {
+ /* Give prefix match a very good score */
+ main_cmds.names[i]->len = 0;
+ continue;
+ }
+ }
+
+ main_cmds.names[i]->len =
+ levenshtein(cmd, candidate, 0, 2, 1, 3) + 1;
+ }
+ FREE_AND_NULL(common_cmds);
+
+ QSORT(main_cmds.names, main_cmds.cnt, levenshtein_compare);
+
+ if (!main_cmds.cnt)
+ die(_("Uh oh. Your system reports no Git commands at all."));
+
+ /* skip and count prefix matches */
+ for (n = 0; n < main_cmds.cnt && !main_cmds.names[n]->len; n++)
+ ; /* still counting */
+
+ if (main_cmds.cnt <= n) {
+ /* prefix matches with everything? that is too ambiguous */
+ best_similarity = SIMILARITY_FLOOR + 1;
+ } else {
+ /* count all the most similar ones */
+ for (best_similarity = main_cmds.names[n++]->len;
+ (n < main_cmds.cnt &&
+ best_similarity == main_cmds.names[n]->len);
+ n++)
+ ; /* still counting */
+ }
+ if (autocorrect && n == 1 && SIMILAR_ENOUGH(best_similarity)) {
+ const char *assumed = main_cmds.names[0]->name;
+ main_cmds.names[0] = NULL;
+ clean_cmdnames(&main_cmds);
+ fprintf_ln(stderr,
+ _("WARNING: You called a Git command named '%s', "
+ "which does not exist."),
+ cmd);
+ if (autocorrect < 0)
+ fprintf_ln(stderr,
+ _("Continuing under the assumption that "
+ "you meant '%s'."),
+ assumed);
+ else {
+ fprintf_ln(stderr,
+ _("Continuing in %0.1f seconds, "
+ "assuming that you meant '%s'."),
+ (float)autocorrect/10.0, assumed);
+ sleep_millisec(autocorrect * 100);
+ }
+ return assumed;
+ }
+
+ fprintf_ln(stderr, _("git: '%s' is not a git command. See 'git --help'."), cmd);
+
+ if (SIMILAR_ENOUGH(best_similarity)) {
+ fprintf_ln(stderr,
+ Q_("\nThe most similar command is",
+ "\nThe most similar commands are",
+ n));
+
+ for (i = 0; i < n; i++)
+ fprintf(stderr, "\t%s\n", main_cmds.names[i]->name);
+ }
+
exit(1);
}
int cmd_version(int argc, const char **argv, const char *prefix)
{
+ int build_options = 0;
+ const char * const usage[] = {
+ N_("git version [<options>]"),
+ NULL
+ };
+ struct option options[] = {
+ OPT_BOOL(0, "build-options", &build_options,
+ "also print build options"),
+ OPT_END()
+ };
+
+ argc = parse_options(argc, argv, prefix, options, usage, 0);
+
+ /*
+ * The format of this string should be kept stable for compatibility
+ * with external projects that rely on the output of "git version".
+ *
+ * Always show the version, even if other options are given.
+ */
printf("git version %s\n", git_version_string);
+
+ if (build_options) {
+ printf("cpu: %s\n", GIT_HOST_CPU);
+ if (git_built_from_commit_string[0])
+ printf("built from commit: %s\n",
+ git_built_from_commit_string);
+ else
+ printf("no commit associated with this build\n");
+ printf("sizeof-long: %d\n", (int)sizeof(long));
+ printf("sizeof-size_t: %d\n", (int)sizeof(size_t));
+ /* NEEDSWORK: also save and output GIT-BUILD_OPTIONS? */
+ }
return 0;
}
-int cmd_help(int argc, const char **argv, const char *prefix)
+struct similar_ref_cb {
+ const char *base_ref;
+ struct string_list *similar_refs;
+};
+
+static int append_similar_ref(const char *refname, const struct object_id *oid,
+ int flags, void *cb_data)
{
- int nongit;
- const char *alias;
+ struct similar_ref_cb *cb = (struct similar_ref_cb *)(cb_data);
+ char *branch = strrchr(refname, '/') + 1;
+ const char *remote;
- setup_git_directory_gently(&nongit);
- git_config(git_help_config, NULL);
+ /* A remote branch of the same name is deemed similar */
+ if (skip_prefix(refname, "refs/remotes/", &remote) &&
+ !strcmp(branch, cb->base_ref))
+ string_list_append(cb->similar_refs, remote);
+ return 0;
+}
- argc = parse_options(argc, argv, builtin_help_options,
- builtin_help_usage, 0);
+static struct string_list guess_refs(const char *ref)
+{
+ struct similar_ref_cb ref_cb;
+ struct string_list similar_refs = STRING_LIST_INIT_NODUP;
- if (show_all) {
- printf("usage: %s\n\n", git_usage_string);
- list_commands();
- printf("%s\n", git_more_info_string);
- return 0;
- }
+ ref_cb.base_ref = ref;
+ ref_cb.similar_refs = &similar_refs;
+ for_each_ref(append_similar_ref, &ref_cb);
+ return similar_refs;
+}
- if (!argv[0]) {
- printf("usage: %s\n\n", git_usage_string);
- list_common_cmds_help();
- printf("\n%s\n", git_more_info_string);
- return 0;
- }
+void help_unknown_ref(const char *ref, const char *cmd, const char *error)
+{
+ int i;
+ struct string_list suggested_refs = guess_refs(ref);
- alias = alias_lookup(argv[0]);
- if (alias && !is_git_command(argv[0])) {
- printf("`git %s' is aliased to `%s'\n", argv[0], alias);
- return 0;
- }
+ fprintf_ln(stderr, _("%s: %s - %s"), cmd, ref, error);
- switch (help_format) {
- case HELP_FORMAT_MAN:
- show_man_page(argv[0]);
- break;
- case HELP_FORMAT_INFO:
- show_info_page(argv[0]);
- break;
- case HELP_FORMAT_WEB:
- show_html_page(argv[0]);
- break;
+ if (suggested_refs.nr > 0) {
+ fprintf_ln(stderr,
+ Q_("\nDid you mean this?",
+ "\nDid you mean one of these?",
+ suggested_refs.nr));
+ for (i = 0; i < suggested_refs.nr; i++)
+ fprintf(stderr, "\t%s\n", suggested_refs.items[i].string);
}
- return 0;
+ string_list_clear(&suggested_refs, 0);
+ exit(1);
}