5 #include "run-command.h"
6 #include "levenshtein.h"
8 #include "command-list.h"
9 #include "string-list.h"
13 #include "parse-options.h"
15 struct category_description
{
19 static uint32_t common_mask
=
20 CAT_init
| CAT_worktree
| CAT_info
|
21 CAT_history
| CAT_remote
;
22 static struct category_description common_categories
[] = {
23 { CAT_init
, N_("start a working area (see also: git help tutorial)") },
24 { CAT_worktree
, N_("work on the current change (see also: git help everyday)") },
25 { CAT_info
, N_("examine the history and state (see also: git help revisions)") },
26 { CAT_history
, N_("grow, mark and tweak your common history") },
27 { CAT_remote
, N_("collaborate (see also: git help workflows)") },
30 static struct category_description main_categories
[] = {
31 { CAT_mainporcelain
, N_("Main Porcelain Commands") },
32 { CAT_ancillarymanipulators
, N_("Ancillary Commands / Manipulators") },
33 { CAT_ancillaryinterrogators
, N_("Ancillary Commands / Interrogators") },
34 { CAT_foreignscminterface
, N_("Interacting with Others") },
35 { CAT_plumbingmanipulators
, N_("Low-level Commands / Manipulators") },
36 { CAT_plumbinginterrogators
, N_("Low-level Commands / Interrogators") },
37 { CAT_synchingrepositories
, N_("Low-level Commands / Synching Repositories") },
38 { CAT_purehelpers
, N_("Low-level Commands / Internal Helpers") },
42 static const char *drop_prefix(const char *name
, uint32_t category
)
46 if (skip_prefix(name
, "git-", &new_name
))
48 if (category
== CAT_guide
&& skip_prefix(name
, "git", &new_name
))
54 static void extract_cmds(struct cmdname_help
**p_cmds
, uint32_t mask
)
57 struct cmdname_help
*cmds
;
59 if (ARRAY_SIZE(command_list
) == 0)
60 BUG("empty command_list[] is a sign of broken generate-cmdlist.sh");
62 ALLOC_ARRAY(cmds
, ARRAY_SIZE(command_list
) + 1);
64 for (i
= 0; i
< ARRAY_SIZE(command_list
); i
++) {
65 const struct cmdname_help
*cmd
= command_list
+ i
;
67 if (!(cmd
->category
& mask
))
71 cmds
[nr
].name
= drop_prefix(cmd
->name
, cmd
->category
);
79 static void print_command_list(const struct cmdname_help
*cmds
,
80 uint32_t mask
, int longest
)
84 for (i
= 0; cmds
[i
].name
; i
++) {
85 if (cmds
[i
].category
& mask
) {
86 printf(" %s ", cmds
[i
].name
);
87 mput_char(' ', longest
- strlen(cmds
[i
].name
));
88 puts(_(cmds
[i
].help
));
93 static int cmd_name_cmp(const void *elem1
, const void *elem2
)
95 const struct cmdname_help
*e1
= elem1
;
96 const struct cmdname_help
*e2
= elem2
;
98 return strcmp(e1
->name
, e2
->name
);
101 static void print_cmd_by_category(const struct category_description
*catdesc
)
103 struct cmdname_help
*cmds
;
108 for (i
= 0; catdesc
[i
].desc
; i
++)
109 mask
|= catdesc
[i
].category
;
111 extract_cmds(&cmds
, mask
);
113 for (i
= 0; cmds
[i
].name
; i
++, nr
++) {
114 if (longest
< strlen(cmds
[i
].name
))
115 longest
= strlen(cmds
[i
].name
);
117 QSORT(cmds
, nr
, cmd_name_cmp
);
119 for (i
= 0; catdesc
[i
].desc
; i
++) {
120 uint32_t mask
= catdesc
[i
].category
;
121 const char *desc
= catdesc
[i
].desc
;
123 printf("\n%s\n", _(desc
));
124 print_command_list(cmds
, mask
, longest
);
129 void add_cmdname(struct cmdnames
*cmds
, const char *name
, int len
)
132 FLEX_ALLOC_MEM(ent
, name
, name
, len
);
135 ALLOC_GROW(cmds
->names
, cmds
->cnt
+ 1, cmds
->alloc
);
136 cmds
->names
[cmds
->cnt
++] = ent
;
139 static void clean_cmdnames(struct cmdnames
*cmds
)
142 for (i
= 0; i
< cmds
->cnt
; ++i
)
143 free(cmds
->names
[i
]);
149 static int cmdname_compare(const void *a_
, const void *b_
)
151 struct cmdname
*a
= *(struct cmdname
**)a_
;
152 struct cmdname
*b
= *(struct cmdname
**)b_
;
153 return strcmp(a
->name
, b
->name
);
156 static void uniq(struct cmdnames
*cmds
)
163 for (i
= j
= 1; i
< cmds
->cnt
; i
++) {
164 if (!strcmp(cmds
->names
[i
]->name
, cmds
->names
[j
-1]->name
))
165 free(cmds
->names
[i
]);
167 cmds
->names
[j
++] = cmds
->names
[i
];
173 void exclude_cmds(struct cmdnames
*cmds
, struct cmdnames
*excludes
)
179 while (ci
< cmds
->cnt
&& ei
< excludes
->cnt
) {
180 cmp
= strcmp(cmds
->names
[ci
]->name
, excludes
->names
[ei
]->name
);
182 cmds
->names
[cj
++] = cmds
->names
[ci
++];
185 free(cmds
->names
[ci
++]);
190 while (ci
< cmds
->cnt
)
191 cmds
->names
[cj
++] = cmds
->names
[ci
++];
196 static void pretty_print_cmdnames(struct cmdnames
*cmds
, unsigned int colopts
)
198 struct string_list list
= STRING_LIST_INIT_NODUP
;
199 struct column_options copts
;
202 for (i
= 0; i
< cmds
->cnt
; i
++)
203 string_list_append(&list
, cmds
->names
[i
]->name
);
205 * always enable column display, we only consult column.*
206 * about layout strategy and stuff
208 colopts
= (colopts
& ~COL_ENABLE_MASK
) | COL_ENABLED
;
209 memset(&copts
, 0, sizeof(copts
));
212 print_columns(&list
, colopts
, &copts
);
213 string_list_clear(&list
, 0);
216 static void list_commands_in_dir(struct cmdnames
*cmds
,
220 DIR *dir
= opendir(path
);
222 struct strbuf buf
= STRBUF_INIT
;
230 strbuf_addf(&buf
, "%s/", path
);
233 while ((de
= readdir(dir
)) != NULL
) {
237 if (!skip_prefix(de
->d_name
, prefix
, &ent
))
240 strbuf_setlen(&buf
, len
);
241 strbuf_addstr(&buf
, de
->d_name
);
242 if (!is_executable(buf
.buf
))
245 entlen
= strlen(ent
);
246 strip_suffix(ent
, ".exe", &entlen
);
248 add_cmdname(cmds
, ent
, entlen
);
251 strbuf_release(&buf
);
254 void load_command_list(const char *prefix
,
255 struct cmdnames
*main_cmds
,
256 struct cmdnames
*other_cmds
)
258 const char *env_path
= getenv("PATH");
259 const char *exec_path
= git_exec_path();
262 list_commands_in_dir(main_cmds
, exec_path
, prefix
);
263 QSORT(main_cmds
->names
, main_cmds
->cnt
, cmdname_compare
);
268 char *paths
, *path
, *colon
;
269 path
= paths
= xstrdup(env_path
);
271 if ((colon
= strchr(path
, PATH_SEP
)))
273 if (!exec_path
|| strcmp(path
, exec_path
))
274 list_commands_in_dir(other_cmds
, path
, prefix
);
282 QSORT(other_cmds
->names
, other_cmds
->cnt
, cmdname_compare
);
285 exclude_cmds(other_cmds
, main_cmds
);
288 void list_commands(unsigned int colopts
,
289 struct cmdnames
*main_cmds
, struct cmdnames
*other_cmds
)
291 if (main_cmds
->cnt
) {
292 const char *exec_path
= git_exec_path();
293 printf_ln(_("available git commands in '%s'"), exec_path
);
295 pretty_print_cmdnames(main_cmds
, colopts
);
299 if (other_cmds
->cnt
) {
300 printf_ln(_("git commands available from elsewhere on your $PATH"));
302 pretty_print_cmdnames(other_cmds
, colopts
);
307 void list_common_cmds_help(void)
309 puts(_("These are common Git commands used in various situations:"));
310 print_cmd_by_category(common_categories
);
313 void list_all_main_cmds(struct string_list
*list
)
315 struct cmdnames main_cmds
, other_cmds
;
318 memset(&main_cmds
, 0, sizeof(main_cmds
));
319 memset(&other_cmds
, 0, sizeof(other_cmds
));
320 load_command_list("git-", &main_cmds
, &other_cmds
);
322 for (i
= 0; i
< main_cmds
.cnt
; i
++)
323 string_list_append(list
, main_cmds
.names
[i
]->name
);
325 clean_cmdnames(&main_cmds
);
326 clean_cmdnames(&other_cmds
);
329 void list_all_other_cmds(struct string_list
*list
)
331 struct cmdnames main_cmds
, other_cmds
;
334 memset(&main_cmds
, 0, sizeof(main_cmds
));
335 memset(&other_cmds
, 0, sizeof(other_cmds
));
336 load_command_list("git-", &main_cmds
, &other_cmds
);
338 for (i
= 0; i
< other_cmds
.cnt
; i
++)
339 string_list_append(list
, other_cmds
.names
[i
]->name
);
341 clean_cmdnames(&main_cmds
);
342 clean_cmdnames(&other_cmds
);
345 void list_cmds_by_category(struct string_list
*list
,
348 int i
, n
= ARRAY_SIZE(command_list
);
351 for (i
= 0; category_names
[i
]; i
++) {
352 if (!strcmp(cat
, category_names
[i
])) {
358 die(_("unsupported command listing type '%s'"), cat
);
360 for (i
= 0; i
< n
; i
++) {
361 struct cmdname_help
*cmd
= command_list
+ i
;
363 if (!(cmd
->category
& cat_id
))
365 string_list_append(list
, drop_prefix(cmd
->name
, cmd
->category
));
369 void list_cmds_by_config(struct string_list
*list
)
371 const char *cmd_list
;
374 * There's no actual repository setup at this point (and even
375 * if there is, we don't really care; only global config
376 * matters). If we accidentally set up a repository, it's ok
377 * too since the caller (git --list-cmds=) should exit shortly
380 if (git_config_get_string_const("completion.commands", &cmd_list
))
383 string_list_sort(list
);
384 string_list_remove_duplicates(list
, 0);
387 struct strbuf sb
= STRBUF_INIT
;
388 const char *p
= strchrnul(cmd_list
, ' ');
390 strbuf_add(&sb
, cmd_list
, p
- cmd_list
);
391 if (*cmd_list
== '-')
392 string_list_remove(list
, cmd_list
+ 1, 0);
394 string_list_insert(list
, sb
.buf
);
402 void list_common_guides_help(void)
404 struct category_description catdesc
[] = {
405 { CAT_guide
, N_("The common Git guides are:") },
408 print_cmd_by_category(catdesc
);
412 void list_all_cmds_help(void)
414 print_cmd_by_category(main_categories
);
417 int is_in_cmdlist(struct cmdnames
*c
, const char *s
)
420 for (i
= 0; i
< c
->cnt
; i
++)
421 if (!strcmp(s
, c
->names
[i
]->name
))
426 static int autocorrect
;
427 static struct cmdnames aliases
;
429 static int git_unknown_cmd_config(const char *var
, const char *value
, void *cb
)
433 if (!strcmp(var
, "help.autocorrect"))
434 autocorrect
= git_config_int(var
,value
);
435 /* Also use aliases for command lookup */
436 if (skip_prefix(var
, "alias.", &p
))
437 add_cmdname(&aliases
, p
, strlen(p
));
439 return git_default_config(var
, value
, cb
);
442 static int levenshtein_compare(const void *p1
, const void *p2
)
444 const struct cmdname
*const *c1
= p1
, *const *c2
= p2
;
445 const char *s1
= (*c1
)->name
, *s2
= (*c2
)->name
;
448 return l1
!= l2
? l1
- l2
: strcmp(s1
, s2
);
451 static void add_cmd_list(struct cmdnames
*cmds
, struct cmdnames
*old
)
454 ALLOC_GROW(cmds
->names
, cmds
->cnt
+ old
->cnt
, cmds
->alloc
);
456 for (i
= 0; i
< old
->cnt
; i
++)
457 cmds
->names
[cmds
->cnt
++] = old
->names
[i
];
458 FREE_AND_NULL(old
->names
);
462 /* An empirically derived magic number */
463 #define SIMILARITY_FLOOR 7
464 #define SIMILAR_ENOUGH(x) ((x) < SIMILARITY_FLOOR)
466 static const char bad_interpreter_advice
[] =
467 N_("'%s' appears to be a git command, but we were not\n"
468 "able to execute it. Maybe git-%s is broken?");
470 const char *help_unknown_cmd(const char *cmd
)
472 int i
, n
, best_similarity
= 0;
473 struct cmdnames main_cmds
, other_cmds
;
474 struct cmdname_help
*common_cmds
;
476 memset(&main_cmds
, 0, sizeof(main_cmds
));
477 memset(&other_cmds
, 0, sizeof(other_cmds
));
478 memset(&aliases
, 0, sizeof(aliases
));
480 read_early_config(git_unknown_cmd_config
, NULL
);
482 load_command_list("git-", &main_cmds
, &other_cmds
);
484 add_cmd_list(&main_cmds
, &aliases
);
485 add_cmd_list(&main_cmds
, &other_cmds
);
486 QSORT(main_cmds
.names
, main_cmds
.cnt
, cmdname_compare
);
489 extract_cmds(&common_cmds
, common_mask
);
491 /* This abuses cmdname->len for levenshtein distance */
492 for (i
= 0, n
= 0; i
< main_cmds
.cnt
; i
++) {
493 int cmp
= 0; /* avoid compiler stupidity */
494 const char *candidate
= main_cmds
.names
[i
]->name
;
497 * An exact match means we have the command, but
498 * for some reason exec'ing it gave us ENOENT; probably
499 * it's a bad interpreter in the #! line.
501 if (!strcmp(candidate
, cmd
))
502 die(_(bad_interpreter_advice
), cmd
, cmd
);
504 /* Does the candidate appear in common_cmds list? */
505 while (common_cmds
[n
].name
&&
506 (cmp
= strcmp(common_cmds
[n
].name
, candidate
)) < 0)
508 if (common_cmds
[n
].name
&& !cmp
) {
509 /* Yes, this is one of the common commands */
510 n
++; /* use the entry from common_cmds[] */
511 if (starts_with(candidate
, cmd
)) {
512 /* Give prefix match a very good score */
513 main_cmds
.names
[i
]->len
= 0;
518 main_cmds
.names
[i
]->len
=
519 levenshtein(cmd
, candidate
, 0, 2, 1, 3) + 1;
521 FREE_AND_NULL(common_cmds
);
523 QSORT(main_cmds
.names
, main_cmds
.cnt
, levenshtein_compare
);
526 die(_("Uh oh. Your system reports no Git commands at all."));
528 /* skip and count prefix matches */
529 for (n
= 0; n
< main_cmds
.cnt
&& !main_cmds
.names
[n
]->len
; n
++)
530 ; /* still counting */
532 if (main_cmds
.cnt
<= n
) {
533 /* prefix matches with everything? that is too ambiguous */
534 best_similarity
= SIMILARITY_FLOOR
+ 1;
536 /* count all the most similar ones */
537 for (best_similarity
= main_cmds
.names
[n
++]->len
;
538 (n
< main_cmds
.cnt
&&
539 best_similarity
== main_cmds
.names
[n
]->len
);
541 ; /* still counting */
543 if (autocorrect
&& n
== 1 && SIMILAR_ENOUGH(best_similarity
)) {
544 const char *assumed
= main_cmds
.names
[0]->name
;
545 main_cmds
.names
[0] = NULL
;
546 clean_cmdnames(&main_cmds
);
548 _("WARNING: You called a Git command named '%s', "
549 "which does not exist."),
553 _("Continuing under the assumption that "
558 _("Continuing in %0.1f seconds, "
559 "assuming that you meant '%s'."),
560 (float)autocorrect
/10.0, assumed
);
561 sleep_millisec(autocorrect
* 100);
566 fprintf_ln(stderr
, _("git: '%s' is not a git command. See 'git --help'."), cmd
);
568 if (SIMILAR_ENOUGH(best_similarity
)) {
570 Q_("\nThe most similar command is",
571 "\nThe most similar commands are",
574 for (i
= 0; i
< n
; i
++)
575 fprintf(stderr
, "\t%s\n", main_cmds
.names
[i
]->name
);
581 int cmd_version(int argc
, const char **argv
, const char *prefix
)
583 int build_options
= 0;
584 const char * const usage
[] = {
585 N_("git version [<options>]"),
588 struct option options
[] = {
589 OPT_BOOL(0, "build-options", &build_options
,
590 "also print build options"),
594 argc
= parse_options(argc
, argv
, prefix
, options
, usage
, 0);
597 * The format of this string should be kept stable for compatibility
598 * with external projects that rely on the output of "git version".
600 * Always show the version, even if other options are given.
602 printf("git version %s\n", git_version_string
);
605 printf("cpu: %s\n", GIT_HOST_CPU
);
606 if (git_built_from_commit_string
[0])
607 printf("built from commit: %s\n",
608 git_built_from_commit_string
);
610 printf("no commit associated with this build\n");
611 printf("sizeof-long: %d\n", (int)sizeof(long));
612 /* NEEDSWORK: also save and output GIT-BUILD_OPTIONS? */
617 struct similar_ref_cb
{
618 const char *base_ref
;
619 struct string_list
*similar_refs
;
622 static int append_similar_ref(const char *refname
, const struct object_id
*oid
,
623 int flags
, void *cb_data
)
625 struct similar_ref_cb
*cb
= (struct similar_ref_cb
*)(cb_data
);
626 char *branch
= strrchr(refname
, '/') + 1;
629 /* A remote branch of the same name is deemed similar */
630 if (skip_prefix(refname
, "refs/remotes/", &remote
) &&
631 !strcmp(branch
, cb
->base_ref
))
632 string_list_append(cb
->similar_refs
, remote
);
636 static struct string_list
guess_refs(const char *ref
)
638 struct similar_ref_cb ref_cb
;
639 struct string_list similar_refs
= STRING_LIST_INIT_NODUP
;
641 ref_cb
.base_ref
= ref
;
642 ref_cb
.similar_refs
= &similar_refs
;
643 for_each_ref(append_similar_ref
, &ref_cb
);
647 void help_unknown_ref(const char *ref
, const char *cmd
, const char *error
)
650 struct string_list suggested_refs
= guess_refs(ref
);
652 fprintf_ln(stderr
, _("%s: %s - %s"), cmd
, ref
, error
);
654 if (suggested_refs
.nr
> 0) {
656 Q_("\nDid you mean this?",
657 "\nDid you mean one of these?",
659 for (i
= 0; i
< suggested_refs
.nr
; i
++)
660 fprintf(stderr
, "\t%s\n", suggested_refs
.items
[i
].string
);
663 string_list_clear(&suggested_refs
, 0);