builtin/help.c

   1 /*
   2  * builtin-help.c
   3  *
   4  * Builtin help command
   5  */
   6 #include "cache.h"
   7 #include "builtin.h"
   8 #include "exec_cmd.h"
   9 #include "parse-options.h"
  10 #include "run-command.h"
  11 #include "column.h"
  12 #include "help.h"
  13
  14 #ifndef DEFAULT_HELP_FORMAT
  15 #define DEFAULT_HELP_FORMAT "man"
  16 #endif
  17
  18 static struct man_viewer_list {
  19         struct man_viewer_list *next;
  20         char name[FLEX_ARRAY];
  21 } *man_viewer_list;
  22
  23 static struct man_viewer_info_list {
  24         struct man_viewer_info_list *next;
  25         const char *info;
  26         char name[FLEX_ARRAY];
  27 } *man_viewer_info_list;
  28
  29 enum help_format {
  30         HELP_FORMAT_NONE,
  31         HELP_FORMAT_MAN,
  32         HELP_FORMAT_INFO,
  33         HELP_FORMAT_WEB
  34 };
  35
  36 static const char *html_path;
  37
  38 static int show_all = 0;
  39 static unsigned int colopts;
  40 static enum help_format help_format = HELP_FORMAT_NONE;
  41 static struct option builtin_help_options[] = {
  42         OPT_BOOLEAN('a', "all", &show_all, N_("print all available commands")),
  43         OPT_SET_INT('m', "man", &help_format, N_("show man page"), HELP_FORMAT_MAN),
  44         OPT_SET_INT('w', "web", &help_format, N_("show manual in web browser"),
  45                         HELP_FORMAT_WEB),
  46         OPT_SET_INT('i', "info", &help_format, N_("show info page"),
  47                         HELP_FORMAT_INFO),
  48         OPT_END(),
  49 };
  50
  51 static const char * const builtin_help_usage[] = {
  52         N_("git help [--all] [--man|--web|--info] [command]"),
  53         NULL
  54 };
  55
  56 static enum help_format parse_help_format(const char *format)
  57 {
  58         if (!strcmp(format, "man"))
  59                 return HELP_FORMAT_MAN;
  60         if (!strcmp(format, "info"))
  61                 return HELP_FORMAT_INFO;
  62         if (!strcmp(format, "web") || !strcmp(format, "html"))
  63                 return HELP_FORMAT_WEB;
  64         die(_("unrecognized help format '%s'"), format);
  65 }
  66
  67 static const char *get_man_viewer_info(const char *name)
  68 {
  69         struct man_viewer_info_list *viewer;
  70
  71         for (viewer = man_viewer_info_list; viewer; viewer = viewer->next)
  72         {
  73                 if (!strcasecmp(name, viewer->name))
  74                         return viewer->info;
  75         }
  76         return NULL;
  77 }
  78
  79 static int check_emacsclient_version(void)
  80 {
  81         struct strbuf buffer = STRBUF_INIT;
  82         struct child_process ec_process;
  83         const char *argv_ec[] = { "emacsclient", "--version", NULL };
  84         int version;
  85
  86         /* emacsclient prints its version number on stderr */
  87         memset(&ec_process, 0, sizeof(ec_process));
  88         ec_process.argv = argv_ec;
  89         ec_process.err = -1;
  90         ec_process.stdout_to_stderr = 1;
  91         if (start_command(&ec_process))
  92                 return error(_("Failed to start emacsclient."));
  93
  94         strbuf_read(&buffer, ec_process.err, 20);
  95         close(ec_process.err);
  96
  97         /*
  98          * Don't bother checking return value, because "emacsclient --version"
  99          * seems to always exits with code 1.
 100          */
 101         finish_command(&ec_process);
 102
 103         if (prefixcmp(buffer.buf, "emacsclient")) {
 104                 strbuf_release(&buffer);
 105                 return error(_("Failed to parse emacsclient version."));
 106         }
 107
 108         strbuf_remove(&buffer, 0, strlen("emacsclient"));
 109         version = atoi(buffer.buf);
 110
 111         if (version < 22) {
 112                 strbuf_release(&buffer);
 113                 return error(_("emacsclient version '%d' too old (< 22)."),
 114                         version);
 115         }
 116
 117         strbuf_release(&buffer);
 118         return 0;
 119 }
 120
 121 static void exec_woman_emacs(const char *path, const char *page)
 122 {
 123         if (!check_emacsclient_version()) {
 124                 /* This works only with emacsclient version >= 22. */
 125                 struct strbuf man_page = STRBUF_INIT;
 126
 127                 if (!path)
 128                         path = "emacsclient";
 129                 strbuf_addf(&man_page, "(woman \"%s\")", page);
 130                 execlp(path, "emacsclient", "-e", man_page.buf, (char *)NULL);
 131                 warning(_("failed to exec '%s': %s"), path, strerror(errno));
 132         }
 133 }
 134
 135 static void exec_man_konqueror(const char *path, const char *page)
 136 {
 137         const char *display = getenv("DISPLAY");
 138         if (display && *display) {
 139                 struct strbuf man_page = STRBUF_INIT;
 140                 const char *filename = "kfmclient";
 141
 142                 /* It's simpler to launch konqueror using kfmclient. */
 143                 if (path) {
 144                         const char *file = strrchr(path, '/');
 145                         if (file && !strcmp(file + 1, "konqueror")) {
 146                                 char *new = xstrdup(path);
 147                                 char *dest = strrchr(new, '/');
 148
 149                                 /* strlen("konqueror") == strlen("kfmclient") */
 150                                 strcpy(dest + 1, "kfmclient");
 151                                 path = new;
 152                         }
 153                         if (file)
 154                                 filename = file;
 155                 } else
 156                         path = "kfmclient";
 157                 strbuf_addf(&man_page, "man:%s(1)", page);
 158                 execlp(path, filename, "newTab", man_page.buf, (char *)NULL);
 159                 warning(_("failed to exec '%s': %s"), path, strerror(errno));
 160         }
 161 }
 162
 163 static void exec_man_man(const char *path, const char *page)
 164 {
 165         if (!path)
 166                 path = "man";
 167         execlp(path, "man", page, (char *)NULL);
 168         warning(_("failed to exec '%s': %s"), path, strerror(errno));
 169 }
 170
 171 static void exec_man_cmd(const char *cmd, const char *page)
 172 {
 173         struct strbuf shell_cmd = STRBUF_INIT;
 174         strbuf_addf(&shell_cmd, "%s %s", cmd, page);
 175         execl("/bin/sh", "sh", "-c", shell_cmd.buf, (char *)NULL);
 176         warning(_("failed to exec '%s': %s"), cmd, strerror(errno));
 177 }
 178
 179 static void add_man_viewer(const char *name)
 180 {
 181         struct man_viewer_list **p = &man_viewer_list;
 182         size_t len = strlen(name);
 183
 184         while (*p)
 185                 p = &((*p)->next);
 186         *p = xcalloc(1, (sizeof(**p) + len + 1));
 187         strncpy((*p)->name, name, len);
 188 }
 189
 190 static int supported_man_viewer(const char *name, size_t len)
 191 {
 192         return (!strncasecmp("man", name, len) ||
 193                 !strncasecmp("woman", name, len) ||
 194                 !strncasecmp("konqueror", name, len));
 195 }
 196
 197 static void do_add_man_viewer_info(const char *name,
 198                                    size_t len,
 199                                    const char *value)
 200 {
 201         struct man_viewer_info_list *new = xcalloc(1, sizeof(*new) + len + 1);
 202
 203         strncpy(new->name, name, len);
 204         new->info = xstrdup(value);
 205         new->next = man_viewer_info_list;
 206         man_viewer_info_list = new;
 207 }
 208
 209 static int add_man_viewer_path(const char *name,
 210                                size_t len,
 211                                const char *value)
 212 {
 213         if (supported_man_viewer(name, len))
 214                 do_add_man_viewer_info(name, len, value);
 215         else
 216                 warning(_("'%s': path for unsupported man viewer.\n"
 217                           "Please consider using 'man.<tool>.cmd' instead."),
 218                         name);
 219
 220         return 0;
 221 }
 222
 223 static int add_man_viewer_cmd(const char *name,
 224                               size_t len,
 225                               const char *value)
 226 {
 227         if (supported_man_viewer(name, len))
 228                 warning(_("'%s': cmd for supported man viewer.\n"
 229                           "Please consider using 'man.<tool>.path' instead."),
 230                         name);
 231         else
 232                 do_add_man_viewer_info(name, len, value);
 233
 234         return 0;
 235 }
 236
 237 static int add_man_viewer_info(const char *var, const char *value)
 238 {
 239         const char *name, *subkey;
 240         int namelen;
 241
 242         if (parse_config_key(var, "man", &name, &namelen, &subkey) < 0 || !name)
 243                 return 0;
 244
 245         if (!strcmp(subkey, "path")) {
 246                 if (!value)
 247                         return config_error_nonbool(var);
 248                 return add_man_viewer_path(name, namelen, value);
 249         }
 250         if (!strcmp(subkey, "cmd")) {
 251                 if (!value)
 252                         return config_error_nonbool(var);
 253                 return add_man_viewer_cmd(name, namelen, value);
 254         }
 255
 256         return 0;
 257 }
 258
 259 static int git_help_config(const char *var, const char *value, void *cb)
 260 {
 261         if (!prefixcmp(var, "column."))
 262                 return git_column_config(var, value, "help", &colopts);
 263         if (!strcmp(var, "help.format")) {
 264                 if (!value)
 265                         return config_error_nonbool(var);
 266                 help_format = parse_help_format(value);
 267                 return 0;
 268         }
 269         if (!strcmp(var, "help.htmlpath")) {
 270                 if (!value)
 271                         return config_error_nonbool(var);
 272                 html_path = xstrdup(value);
 273                 return 0;
 274         }
 275         if (!strcmp(var, "man.viewer")) {
 276                 if (!value)
 277                         return config_error_nonbool(var);
 278                 add_man_viewer(value);
 279                 return 0;
 280         }
 281         if (!prefixcmp(var, "man."))
 282                 return add_man_viewer_info(var, value);
 283
 284         return git_default_config(var, value, cb);
 285 }
 286
 287 static struct cmdnames main_cmds, other_cmds;
 288
 289 static int is_git_command(const char *s)
 290 {
 291         return is_in_cmdlist(&main_cmds, s) ||
 292                 is_in_cmdlist(&other_cmds, s);
 293 }
 294
 295 static const char *prepend(const char *prefix, const char *cmd)
 296 {
 297         size_t pre_len = strlen(prefix);
 298         size_t cmd_len = strlen(cmd);
 299         char *p = xmalloc(pre_len + cmd_len + 1);
 300         memcpy(p, prefix, pre_len);
 301         strcpy(p + pre_len, cmd);
 302         return p;
 303 }
 304
 305 static const char *cmd_to_page(const char *git_cmd)
 306 {
 307         if (!git_cmd)
 308                 return "git";
 309         else if (!prefixcmp(git_cmd, "git"))
 310                 return git_cmd;
 311         else if (is_git_command(git_cmd))
 312                 return prepend("git-", git_cmd);
 313         else
 314                 return prepend("git", git_cmd);
 315 }
 316
 317 static void setup_man_path(void)
 318 {
 319         struct strbuf new_path = STRBUF_INIT;
 320         const char *old_path = getenv("MANPATH");
 321
 322         /* We should always put ':' after our path. If there is no
 323          * old_path, the ':' at the end will let 'man' to try
 324          * system-wide paths after ours to find the manual page. If
 325          * there is old_path, we need ':' as delimiter. */
 326         strbuf_addstr(&new_path, system_path(GIT_MAN_PATH));
 327         strbuf_addch(&new_path, ':');
 328         if (old_path)
 329                 strbuf_addstr(&new_path, old_path);
 330
 331         setenv("MANPATH", new_path.buf, 1);
 332
 333         strbuf_release(&new_path);
 334 }
 335
 336 static void exec_viewer(const char *name, const char *page)
 337 {
 338         const char *info = get_man_viewer_info(name);
 339
 340         if (!strcasecmp(name, "man"))
 341                 exec_man_man(info, page);
 342         else if (!strcasecmp(name, "woman"))
 343                 exec_woman_emacs(info, page);
 344         else if (!strcasecmp(name, "konqueror"))
 345                 exec_man_konqueror(info, page);
 346         else if (info)
 347                 exec_man_cmd(info, page);
 348         else
 349                 warning(_("'%s': unknown man viewer."), name);
 350 }
 351
 352 static void show_man_page(const char *git_cmd)
 353 {
 354         struct man_viewer_list *viewer;
 355         const char *page = cmd_to_page(git_cmd);
 356         const char *fallback = getenv("GIT_MAN_VIEWER");
 357
 358         setup_man_path();
 359         for (viewer = man_viewer_list; viewer; viewer = viewer->next)
 360         {
 361                 exec_viewer(viewer->name, page); /* will return when unable */
 362         }
 363         if (fallback)
 364                 exec_viewer(fallback, page);
 365         exec_viewer("man", page);
 366         die(_("no man viewer handled the request"));
 367 }
 368
 369 static void show_info_page(const char *git_cmd)
 370 {
 371         const char *page = cmd_to_page(git_cmd);
 372         setenv("INFOPATH", system_path(GIT_INFO_PATH), 1);
 373         execlp("info", "info", "gitman", page, (char *)NULL);
 374         die(_("no info viewer handled the request"));
 375 }
 376
 377 static void get_html_page_path(struct strbuf *page_path, const char *page)
 378 {
 379         struct stat st;
 380         if (!html_path)
 381                 html_path = system_path(GIT_HTML_PATH);
 382
 383         /* Check that we have a git documentation directory. */
 384         if (!strstr(html_path, "://")) {
 385                 if (stat(mkpath("%s/git.html", html_path), &st)
 386                     || !S_ISREG(st.st_mode))
 387                         die("'%s': not a documentation directory.", html_path);
 388         }
 389
 390         strbuf_init(page_path, 0);
 391         strbuf_addf(page_path, "%s/%s.html", html_path, page);
 392 }
 393
 394 /*
 395  * If open_html is not defined in a platform-specific way (see for
 396  * example compat/mingw.h), we use the script web--browse to display
 397  * HTML.
 398  */
 399 #ifndef open_html
 400 static void open_html(const char *path)
 401 {
 402         execl_git_cmd("web--browse", "-c", "help.browser", path, (char *)NULL);
 403 }
 404 #endif
 405
 406 static void show_html_page(const char *git_cmd)
 407 {
 408         const char *page = cmd_to_page(git_cmd);
 409         struct strbuf page_path; /* it leaks but we exec bellow */
 410
 411         get_html_page_path(&page_path, page);
 412
 413         open_html(page_path.buf);
 414 }
 415
 416 int cmd_help(int argc, const char **argv, const char *prefix)
 417 {
 418         int nongit;
 419         const char *alias;
 420         enum help_format parsed_help_format;
 421         load_command_list("git-", &main_cmds, &other_cmds);
 422
 423         argc = parse_options(argc, argv, prefix, builtin_help_options,
 424                         builtin_help_usage, 0);
 425         parsed_help_format = help_format;
 426
 427         if (show_all) {
 428                 git_config(git_help_config, NULL);
 429                 printf(_("usage: %s%s"), _(git_usage_string), "\n\n");
 430                 list_commands(colopts, &main_cmds, &other_cmds);
 431                 printf("%s\n", _(git_more_info_string));
 432                 return 0;
 433         }
 434
 435         if (!argv[0]) {
 436                 printf(_("usage: %s%s"), _(git_usage_string), "\n\n");
 437                 list_common_cmds_help();
 438                 printf("\n%s\n", _(git_more_info_string));
 439                 return 0;
 440         }
 441
 442         setup_git_directory_gently(&nongit);
 443         git_config(git_help_config, NULL);
 444
 445         if (parsed_help_format != HELP_FORMAT_NONE)
 446                 help_format = parsed_help_format;
 447         if (help_format == HELP_FORMAT_NONE)
 448                 help_format = parse_help_format(DEFAULT_HELP_FORMAT);
 449
 450         alias = alias_lookup(argv[0]);
 451         if (alias && !is_git_command(argv[0])) {
 452                 printf_ln(_("`git %s' is aliased to `%s'"), argv[0], alias);
 453                 return 0;
 454         }
 455
 456         switch (help_format) {
 457         case HELP_FORMAT_NONE:
 458         case HELP_FORMAT_MAN:
 459                 show_man_page(argv[0]);
 460                 break;
 461         case HELP_FORMAT_INFO:
 462                 show_info_page(argv[0]);
 463                 break;
 464         case HELP_FORMAT_WEB:
 465                 show_html_page(argv[0]);
 466                 break;
 467         }
 468
 469         return 0;
 470 }