Merge branch 'sb/help-unknown-command-sort-fix'
authorJunio C Hamano <gitster@pobox.com>
Fri, 26 Sep 2014 21:39:46 +0000 (14:39 -0700)
committerJunio C Hamano <gitster@pobox.com>
Fri, 26 Sep 2014 21:39:49 +0000 (14:39 -0700)
Code cleanup.

* sb/help-unknown-command-sort-fix:
help: fix the size passed to qsort

1  2 
help.c
diff --combined help.c
index 7af65e205ecdf1a01dce009cbf0ada15de68c844,3678d6a98b6ca119d24be58783450c167673de9b..2072a873e2db784ca66c0f1736b12e523a96b7db
--- 1/help.c
--- 2/help.c
+++ b/help.c
@@@ -3,11 -3,28 +3,11 @@@
  #include "exec_cmd.h"
  #include "levenshtein.h"
  #include "help.h"
 -
 -/* 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;
 -              }
 -      }
 -#endif
 -
 -      return 80;
 -}
 +#include "common-cmds.h"
 +#include "string-list.h"
 +#include "column.h"
 +#include "version.h"
 +#include "refs.h"
  
  void add_cmdname(struct cmdnames *cmds, const char *name, int len)
  {
@@@ -45,12 -62,9 +45,12 @@@ static void uniq(struct cmdnames *cmds
        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;
  }
@@@ -65,10 -79,9 +65,10 @@@ void exclude_cmds(struct cmdnames *cmds
                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("  ");
 +      struct string_list list = STRING_LIST_INIT_NODUP;
 +      struct column_options copts;
 +      int i;
  
 -              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');
 -      }
 +      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 int is_executable(const char *name)
            !S_ISREG(st.st_mode))
                return 0;
  
 -#ifdef __MINGW32__
 -      /* cannot trust the executable bit, peek into the file instead */
 +#if defined(GIT_WINDOWS_NATIVE)
 +{     /* 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;
                close(fd);
        }
 +}
  #endif
        return st.st_mode & S_IXUSR;
  }
@@@ -129,6 -148,7 +129,6 @@@ static void list_commands_in_dir(struc
                                         const char *path,
                                         const char *prefix)
  {
 -      int prefix_len;
        DIR *dir = opendir(path);
        struct dirent *de;
        struct strbuf buf = STRBUF_INIT;
                return;
        if (!prefix)
                prefix = "git-";
 -      prefix_len = strlen(prefix);
  
        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);
  
 -              add_cmdname(cmds, de->d_name + prefix_len, entlen);
 +              add_cmdname(cmds, ent, entlen);
        }
        closedir(dir);
        strbuf_release(&buf);
@@@ -199,42 -220,38 +199,42 @@@ void load_command_list(const char *pref
        exclude_cmds(other_cmds, main_cmds);
  }
  
 -void list_commands(const char *title, struct cmdnames *main_cmds,
 -                 struct cmdnames *other_cmds)
 +void list_commands(unsigned int colopts,
 +                 struct cmdnames *main_cmds, struct cmdnames *other_cmds)
  {
 -      int i, longest = 0;
 -
 -      for (i = 0; i < main_cmds->cnt; i++)
 -              if (longest < main_cmds->names[i]->len)
 -                      longest = main_cmds->names[i]->len;
 -      for (i = 0; i < other_cmds->cnt; i++)
 -              if (longest < other_cmds->names[i]->len)
 -                      longest = other_cmds->names[i]->len;
 -
        if (main_cmds->cnt) {
                const char *exec_path = git_exec_path();
 -              printf("available %s in '%s'\n", title, exec_path);
 -              printf("----------------");
 -              mput_char('-', strlen(title) + strlen(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("%s available from elsewhere on your $PATH\n", title);
 -              printf("---------------------------------------");
 -              mput_char('-', strlen(title));
 +              printf_ln(_("git commands available from elsewhere on your $PATH"));
                putchar('\n');
 -              pretty_print_string_list(other_cmds, longest);
 +              pretty_print_cmdnames(other_cmds, colopts);
                putchar('\n');
        }
  }
  
 +void list_common_cmds_help(void)
 +{
 +      int i, longest = 0;
 +
 +      for (i = 0; i < ARRAY_SIZE(common_cmds); i++) {
 +              if (longest < strlen(common_cmds[i].name))
 +                      longest = strlen(common_cmds[i].name);
 +      }
 +
 +      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));
 +      }
 +}
 +
  int is_in_cmdlist(struct cmdnames *c, const char *s)
  {
        int i;
@@@ -249,13 -266,11 +249,13 @@@ static struct cmdnames aliases
  
  static int git_unknown_cmd_config(const char *var, const char *value, void *cb)
  {
 +      const char *p;
 +
        if (!strcmp(var, "help.autocorrect"))
                autocorrect = git_config_int(var,value);
        /* Also use aliases for command lookup */
 -      if (!prefixcmp(var, "alias."))
 -              add_cmdname(&aliases, var + 6, strlen(var + 6));
 +      if (skip_prefix(var, "alias.", &p))
 +              add_cmdname(&aliases, p, strlen(p));
  
        return git_default_config(var, value, cb);
  }
@@@ -281,21 -296,13 +281,21 @@@ static void add_cmd_list(struct cmdname
        old->names = NULL;
  }
  
 +/* 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)
  {
        int i, n, best_similarity = 0;
        struct cmdnames main_cmds, other_cmds;
  
        memset(&main_cmds, 0, sizeof(main_cmds));
 -      memset(&other_cmds, 0, sizeof(main_cmds));
 +      memset(&other_cmds, 0, sizeof(other_cmds));
        memset(&aliases, 0, sizeof(aliases));
  
        git_config(git_unknown_cmd_config, NULL);
        add_cmd_list(&main_cmds, &aliases);
        add_cmd_list(&main_cmds, &other_cmds);
        qsort(main_cmds.names, main_cmds.cnt,
-             sizeof(main_cmds.names), cmdname_compare);
+             sizeof(*main_cmds.names), cmdname_compare);
        uniq(&main_cmds);
  
 -      /* This reuses cmdname->len for similarity index */
 -      for (i = 0; i < main_cmds.cnt; ++i)
 +      /* 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 (n < ARRAY_SIZE(common_cmds) &&
 +                     (cmp = strcmp(common_cmds[n].name, candidate)) < 0)
 +                      n++;
 +              if ((n < ARRAY_SIZE(common_cmds)) && !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, main_cmds.names[i]->name, 0, 2, 1, 4);
 +                      levenshtein(cmd, candidate, 0, 2, 1, 3) + 1;
 +      }
  
        qsort(main_cmds.names, main_cmds.cnt,
              sizeof(*main_cmds.names), levenshtein_compare);
  
        if (!main_cmds.cnt)
 -              die ("Uh oh. Your system reports no Git commands at all.");
 -
 -      best_similarity = main_cmds.names[0]->len;
 -      n = 1;
 -      while (n < main_cmds.cnt && best_similarity == main_cmds.names[n]->len)
 -              ++n;
 -      if (autocorrect && n == 1) {
 +              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(stderr, "WARNING: You called a Git program named '%s', "
 -                      "which does not exist.\n"
 -                      "Continuing under the assumption that you meant '%s'\n",
 +              fprintf_ln(stderr,
 +                         _("WARNING: You called a Git command named '%s', "
 +                           "which does not exist.\n"
 +                           "Continuing under the assumption that you meant '%s'"),
                        cmd, assumed);
                if (autocorrect > 0) {
 -                      fprintf(stderr, "in %0.1f seconds automatically...\n",
 +                      fprintf_ln(stderr, _("in %0.1f seconds automatically..."),
                                (float)autocorrect/10.0);
                        poll(NULL, 0, autocorrect * 100);
                }
                return assumed;
        }
  
 -      fprintf(stderr, "git: '%s' is not a git-command. See 'git --help'.\n", cmd);
 +      fprintf_ln(stderr, _("git: '%s' is not a git command. See 'git --help'."), cmd);
  
 -      if (best_similarity < 6) {
 -              fprintf(stderr, "\nDid you mean %s?\n",
 -                      n < 2 ? "this": "one of these");
 +      if (SIMILAR_ENOUGH(best_similarity)) {
 +              fprintf_ln(stderr,
 +                         Q_("\nDid you mean this?",
 +                            "\nDid you mean one of these?",
 +                         n));
  
                for (i = 0; i < n; i++)
                        fprintf(stderr, "\t%s\n", main_cmds.names[i]->name);
  
  int cmd_version(int argc, const char **argv, const char *prefix)
  {
 +      /*
 +       * The format of this string should be kept stable for compatibility
 +       * with external projects that rely on the output of "git version".
 +       */
        printf("git version %s\n", git_version_string);
        return 0;
  }
 +
 +struct similar_ref_cb {
 +      const char *base_ref;
 +      struct string_list *similar_refs;
 +};
 +
 +static int append_similar_ref(const char *refname, const unsigned char *sha1,
 +                            int flags, void *cb_data)
 +{
 +      struct similar_ref_cb *cb = (struct similar_ref_cb *)(cb_data);
 +      char *branch = strrchr(refname, '/') + 1;
 +      const char *remote;
 +
 +      /* 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;
 +}
 +
 +static struct string_list guess_refs(const char *ref)
 +{
 +      struct similar_ref_cb ref_cb;
 +      struct string_list similar_refs = STRING_LIST_INIT_NODUP;
 +
 +      ref_cb.base_ref = ref;
 +      ref_cb.similar_refs = &similar_refs;
 +      for_each_ref(append_similar_ref, &ref_cb);
 +      return similar_refs;
 +}
 +
 +void help_unknown_ref(const char *ref, const char *cmd, const char *error)
 +{
 +      int i;
 +      struct string_list suggested_refs = guess_refs(ref);
 +
 +      fprintf_ln(stderr, _("%s: %s - %s"), cmd, ref, error);
 +
 +      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);
 +      }
 +
 +      string_list_clear(&suggested_refs, 0);
 +      exit(1);
 +}