Merge branch 'jt/fsck-code-cleanup' into maint
[git] / help.c
1 #include "cache.h"
2 #include "config.h"
3 #include "builtin.h"
4 #include "exec_cmd.h"
5 #include "run-command.h"
6 #include "levenshtein.h"
7 #include "help.h"
8 #include "common-cmds.h"
9 #include "string-list.h"
10 #include "column.h"
11 #include "version.h"
12 #include "refs.h"
13 #include "parse-options.h"
14
15 void add_cmdname(struct cmdnames *cmds, const char *name, int len)
16 {
17         struct cmdname *ent;
18         FLEX_ALLOC_MEM(ent, name, name, len);
19         ent->len = len;
20
21         ALLOC_GROW(cmds->names, cmds->cnt + 1, cmds->alloc);
22         cmds->names[cmds->cnt++] = ent;
23 }
24
25 static void clean_cmdnames(struct cmdnames *cmds)
26 {
27         int i;
28         for (i = 0; i < cmds->cnt; ++i)
29                 free(cmds->names[i]);
30         free(cmds->names);
31         cmds->cnt = 0;
32         cmds->alloc = 0;
33 }
34
35 static int cmdname_compare(const void *a_, const void *b_)
36 {
37         struct cmdname *a = *(struct cmdname **)a_;
38         struct cmdname *b = *(struct cmdname **)b_;
39         return strcmp(a->name, b->name);
40 }
41
42 static void uniq(struct cmdnames *cmds)
43 {
44         int i, j;
45
46         if (!cmds->cnt)
47                 return;
48
49         for (i = j = 1; i < cmds->cnt; i++) {
50                 if (!strcmp(cmds->names[i]->name, cmds->names[j-1]->name))
51                         free(cmds->names[i]);
52                 else
53                         cmds->names[j++] = cmds->names[i];
54         }
55
56         cmds->cnt = j;
57 }
58
59 void exclude_cmds(struct cmdnames *cmds, struct cmdnames *excludes)
60 {
61         int ci, cj, ei;
62         int cmp;
63
64         ci = cj = ei = 0;
65         while (ci < cmds->cnt && ei < excludes->cnt) {
66                 cmp = strcmp(cmds->names[ci]->name, excludes->names[ei]->name);
67                 if (cmp < 0)
68                         cmds->names[cj++] = cmds->names[ci++];
69                 else if (cmp == 0) {
70                         ei++;
71                         free(cmds->names[ci++]);
72                 } else if (cmp > 0)
73                         ei++;
74         }
75
76         while (ci < cmds->cnt)
77                 cmds->names[cj++] = cmds->names[ci++];
78
79         cmds->cnt = cj;
80 }
81
82 static void pretty_print_cmdnames(struct cmdnames *cmds, unsigned int colopts)
83 {
84         struct string_list list = STRING_LIST_INIT_NODUP;
85         struct column_options copts;
86         int i;
87
88         for (i = 0; i < cmds->cnt; i++)
89                 string_list_append(&list, cmds->names[i]->name);
90         /*
91          * always enable column display, we only consult column.*
92          * about layout strategy and stuff
93          */
94         colopts = (colopts & ~COL_ENABLE_MASK) | COL_ENABLED;
95         memset(&copts, 0, sizeof(copts));
96         copts.indent = "  ";
97         copts.padding = 2;
98         print_columns(&list, colopts, &copts);
99         string_list_clear(&list, 0);
100 }
101
102 static void list_commands_in_dir(struct cmdnames *cmds,
103                                          const char *path,
104                                          const char *prefix)
105 {
106         DIR *dir = opendir(path);
107         struct dirent *de;
108         struct strbuf buf = STRBUF_INIT;
109         int len;
110
111         if (!dir)
112                 return;
113         if (!prefix)
114                 prefix = "git-";
115
116         strbuf_addf(&buf, "%s/", path);
117         len = buf.len;
118
119         while ((de = readdir(dir)) != NULL) {
120                 const char *ent;
121                 size_t entlen;
122
123                 if (!skip_prefix(de->d_name, prefix, &ent))
124                         continue;
125
126                 strbuf_setlen(&buf, len);
127                 strbuf_addstr(&buf, de->d_name);
128                 if (!is_executable(buf.buf))
129                         continue;
130
131                 entlen = strlen(ent);
132                 strip_suffix(ent, ".exe", &entlen);
133
134                 add_cmdname(cmds, ent, entlen);
135         }
136         closedir(dir);
137         strbuf_release(&buf);
138 }
139
140 void load_command_list(const char *prefix,
141                 struct cmdnames *main_cmds,
142                 struct cmdnames *other_cmds)
143 {
144         const char *env_path = getenv("PATH");
145         const char *exec_path = git_exec_path();
146
147         if (exec_path) {
148                 list_commands_in_dir(main_cmds, exec_path, prefix);
149                 QSORT(main_cmds->names, main_cmds->cnt, cmdname_compare);
150                 uniq(main_cmds);
151         }
152
153         if (env_path) {
154                 char *paths, *path, *colon;
155                 path = paths = xstrdup(env_path);
156                 while (1) {
157                         if ((colon = strchr(path, PATH_SEP)))
158                                 *colon = 0;
159                         if (!exec_path || strcmp(path, exec_path))
160                                 list_commands_in_dir(other_cmds, path, prefix);
161
162                         if (!colon)
163                                 break;
164                         path = colon + 1;
165                 }
166                 free(paths);
167
168                 QSORT(other_cmds->names, other_cmds->cnt, cmdname_compare);
169                 uniq(other_cmds);
170         }
171         exclude_cmds(other_cmds, main_cmds);
172 }
173
174 void list_commands(unsigned int colopts,
175                    struct cmdnames *main_cmds, struct cmdnames *other_cmds)
176 {
177         if (main_cmds->cnt) {
178                 const char *exec_path = git_exec_path();
179                 printf_ln(_("available git commands in '%s'"), exec_path);
180                 putchar('\n');
181                 pretty_print_cmdnames(main_cmds, colopts);
182                 putchar('\n');
183         }
184
185         if (other_cmds->cnt) {
186                 printf_ln(_("git commands available from elsewhere on your $PATH"));
187                 putchar('\n');
188                 pretty_print_cmdnames(other_cmds, colopts);
189                 putchar('\n');
190         }
191 }
192
193 static int cmd_group_cmp(const void *elem1, const void *elem2)
194 {
195         const struct cmdname_help *e1 = elem1;
196         const struct cmdname_help *e2 = elem2;
197
198         if (e1->group < e2->group)
199                 return -1;
200         if (e1->group > e2->group)
201                 return 1;
202         return strcmp(e1->name, e2->name);
203 }
204
205 void list_common_cmds_help(void)
206 {
207         int i, longest = 0;
208         int current_grp = -1;
209
210         for (i = 0; i < ARRAY_SIZE(common_cmds); i++) {
211                 if (longest < strlen(common_cmds[i].name))
212                         longest = strlen(common_cmds[i].name);
213         }
214
215         QSORT(common_cmds, ARRAY_SIZE(common_cmds), cmd_group_cmp);
216
217         puts(_("These are common Git commands used in various situations:"));
218
219         for (i = 0; i < ARRAY_SIZE(common_cmds); i++) {
220                 if (common_cmds[i].group != current_grp) {
221                         printf("\n%s\n", _(common_cmd_groups[common_cmds[i].group]));
222                         current_grp = common_cmds[i].group;
223                 }
224
225                 printf("   %s   ", common_cmds[i].name);
226                 mput_char(' ', longest - strlen(common_cmds[i].name));
227                 puts(_(common_cmds[i].help));
228         }
229 }
230
231 int is_in_cmdlist(struct cmdnames *c, const char *s)
232 {
233         int i;
234         for (i = 0; i < c->cnt; i++)
235                 if (!strcmp(s, c->names[i]->name))
236                         return 1;
237         return 0;
238 }
239
240 static int autocorrect;
241 static struct cmdnames aliases;
242
243 static int git_unknown_cmd_config(const char *var, const char *value, void *cb)
244 {
245         const char *p;
246
247         if (!strcmp(var, "help.autocorrect"))
248                 autocorrect = git_config_int(var,value);
249         /* Also use aliases for command lookup */
250         if (skip_prefix(var, "alias.", &p))
251                 add_cmdname(&aliases, p, strlen(p));
252
253         return git_default_config(var, value, cb);
254 }
255
256 static int levenshtein_compare(const void *p1, const void *p2)
257 {
258         const struct cmdname *const *c1 = p1, *const *c2 = p2;
259         const char *s1 = (*c1)->name, *s2 = (*c2)->name;
260         int l1 = (*c1)->len;
261         int l2 = (*c2)->len;
262         return l1 != l2 ? l1 - l2 : strcmp(s1, s2);
263 }
264
265 static void add_cmd_list(struct cmdnames *cmds, struct cmdnames *old)
266 {
267         int i;
268         ALLOC_GROW(cmds->names, cmds->cnt + old->cnt, cmds->alloc);
269
270         for (i = 0; i < old->cnt; i++)
271                 cmds->names[cmds->cnt++] = old->names[i];
272         FREE_AND_NULL(old->names);
273         old->cnt = 0;
274 }
275
276 /* An empirically derived magic number */
277 #define SIMILARITY_FLOOR 7
278 #define SIMILAR_ENOUGH(x) ((x) < SIMILARITY_FLOOR)
279
280 static const char bad_interpreter_advice[] =
281         N_("'%s' appears to be a git command, but we were not\n"
282         "able to execute it. Maybe git-%s is broken?");
283
284 const char *help_unknown_cmd(const char *cmd)
285 {
286         int i, n, best_similarity = 0;
287         struct cmdnames main_cmds, other_cmds;
288
289         memset(&main_cmds, 0, sizeof(main_cmds));
290         memset(&other_cmds, 0, sizeof(other_cmds));
291         memset(&aliases, 0, sizeof(aliases));
292
293         read_early_config(git_unknown_cmd_config, NULL);
294
295         load_command_list("git-", &main_cmds, &other_cmds);
296
297         add_cmd_list(&main_cmds, &aliases);
298         add_cmd_list(&main_cmds, &other_cmds);
299         QSORT(main_cmds.names, main_cmds.cnt, cmdname_compare);
300         uniq(&main_cmds);
301
302         /* This abuses cmdname->len for levenshtein distance */
303         for (i = 0, n = 0; i < main_cmds.cnt; i++) {
304                 int cmp = 0; /* avoid compiler stupidity */
305                 const char *candidate = main_cmds.names[i]->name;
306
307                 /*
308                  * An exact match means we have the command, but
309                  * for some reason exec'ing it gave us ENOENT; probably
310                  * it's a bad interpreter in the #! line.
311                  */
312                 if (!strcmp(candidate, cmd))
313                         die(_(bad_interpreter_advice), cmd, cmd);
314
315                 /* Does the candidate appear in common_cmds list? */
316                 while (n < ARRAY_SIZE(common_cmds) &&
317                        (cmp = strcmp(common_cmds[n].name, candidate)) < 0)
318                         n++;
319                 if ((n < ARRAY_SIZE(common_cmds)) && !cmp) {
320                         /* Yes, this is one of the common commands */
321                         n++; /* use the entry from common_cmds[] */
322                         if (starts_with(candidate, cmd)) {
323                                 /* Give prefix match a very good score */
324                                 main_cmds.names[i]->len = 0;
325                                 continue;
326                         }
327                 }
328
329                 main_cmds.names[i]->len =
330                         levenshtein(cmd, candidate, 0, 2, 1, 3) + 1;
331         }
332
333         QSORT(main_cmds.names, main_cmds.cnt, levenshtein_compare);
334
335         if (!main_cmds.cnt)
336                 die(_("Uh oh. Your system reports no Git commands at all."));
337
338         /* skip and count prefix matches */
339         for (n = 0; n < main_cmds.cnt && !main_cmds.names[n]->len; n++)
340                 ; /* still counting */
341
342         if (main_cmds.cnt <= n) {
343                 /* prefix matches with everything? that is too ambiguous */
344                 best_similarity = SIMILARITY_FLOOR + 1;
345         } else {
346                 /* count all the most similar ones */
347                 for (best_similarity = main_cmds.names[n++]->len;
348                      (n < main_cmds.cnt &&
349                       best_similarity == main_cmds.names[n]->len);
350                      n++)
351                         ; /* still counting */
352         }
353         if (autocorrect && n == 1 && SIMILAR_ENOUGH(best_similarity)) {
354                 const char *assumed = main_cmds.names[0]->name;
355                 main_cmds.names[0] = NULL;
356                 clean_cmdnames(&main_cmds);
357                 fprintf_ln(stderr,
358                            _("WARNING: You called a Git command named '%s', "
359                              "which does not exist."),
360                            cmd);
361                 if (autocorrect < 0)
362                         fprintf_ln(stderr,
363                                    _("Continuing under the assumption that "
364                                      "you meant '%s'."),
365                                    assumed);
366                 else {
367                         fprintf_ln(stderr,
368                                    _("Continuing in %0.1f seconds, "
369                                      "assuming that you meant '%s'."),
370                                    (float)autocorrect/10.0, assumed);
371                         sleep_millisec(autocorrect * 100);
372                 }
373                 return assumed;
374         }
375
376         fprintf_ln(stderr, _("git: '%s' is not a git command. See 'git --help'."), cmd);
377
378         if (SIMILAR_ENOUGH(best_similarity)) {
379                 fprintf_ln(stderr,
380                            Q_("\nThe most similar command is",
381                               "\nThe most similar commands are",
382                            n));
383
384                 for (i = 0; i < n; i++)
385                         fprintf(stderr, "\t%s\n", main_cmds.names[i]->name);
386         }
387
388         exit(1);
389 }
390
391 int cmd_version(int argc, const char **argv, const char *prefix)
392 {
393         int build_options = 0;
394         const char * const usage[] = {
395                 N_("git version [<options>]"),
396                 NULL
397         };
398         struct option options[] = {
399                 OPT_BOOL(0, "build-options", &build_options,
400                          "also print build options"),
401                 OPT_END()
402         };
403
404         argc = parse_options(argc, argv, prefix, options, usage, 0);
405
406         /*
407          * The format of this string should be kept stable for compatibility
408          * with external projects that rely on the output of "git version".
409          *
410          * Always show the version, even if other options are given.
411          */
412         printf("git version %s\n", git_version_string);
413
414         if (build_options) {
415                 printf("cpu: %s\n", GIT_HOST_CPU);
416                 if (git_built_from_commit_string[0])
417                         printf("built from commit: %s\n",
418                                git_built_from_commit_string);
419                 else
420                         printf("no commit associated with this build\n");
421                 printf("sizeof-long: %d\n", (int)sizeof(long));
422                 /* NEEDSWORK: also save and output GIT-BUILD_OPTIONS? */
423         }
424         return 0;
425 }
426
427 struct similar_ref_cb {
428         const char *base_ref;
429         struct string_list *similar_refs;
430 };
431
432 static int append_similar_ref(const char *refname, const struct object_id *oid,
433                               int flags, void *cb_data)
434 {
435         struct similar_ref_cb *cb = (struct similar_ref_cb *)(cb_data);
436         char *branch = strrchr(refname, '/') + 1;
437         const char *remote;
438
439         /* A remote branch of the same name is deemed similar */
440         if (skip_prefix(refname, "refs/remotes/", &remote) &&
441             !strcmp(branch, cb->base_ref))
442                 string_list_append(cb->similar_refs, remote);
443         return 0;
444 }
445
446 static struct string_list guess_refs(const char *ref)
447 {
448         struct similar_ref_cb ref_cb;
449         struct string_list similar_refs = STRING_LIST_INIT_NODUP;
450
451         ref_cb.base_ref = ref;
452         ref_cb.similar_refs = &similar_refs;
453         for_each_ref(append_similar_ref, &ref_cb);
454         return similar_refs;
455 }
456
457 void help_unknown_ref(const char *ref, const char *cmd, const char *error)
458 {
459         int i;
460         struct string_list suggested_refs = guess_refs(ref);
461
462         fprintf_ln(stderr, _("%s: %s - %s"), cmd, ref, error);
463
464         if (suggested_refs.nr > 0) {
465                 fprintf_ln(stderr,
466                            Q_("\nDid you mean this?",
467                               "\nDid you mean one of these?",
468                               suggested_refs.nr));
469                 for (i = 0; i < suggested_refs.nr; i++)
470                         fprintf(stderr, "\t%s\n", suggested_refs.items[i].string);
471         }
472
473         string_list_clear(&suggested_refs, 0);
474         exit(1);
475 }