Document 'git-blame --incremental'
[git] / help.c
1 /*
2  * builtin-help.c
3  *
4  * Builtin help-related commands (help, usage, version)
5  */
6 #include "cache.h"
7 #include "builtin.h"
8 #include "exec_cmd.h"
9 #include "common-cmds.h"
10 #include <sys/ioctl.h>
11
12 /* most GUI terminals set COLUMNS (although some don't export it) */
13 static int term_columns(void)
14 {
15         char *col_string = getenv("COLUMNS");
16         int n_cols;
17
18         if (col_string && (n_cols = atoi(col_string)) > 0)
19                 return n_cols;
20
21 #ifdef TIOCGWINSZ
22         {
23                 struct winsize ws;
24                 if (!ioctl(1, TIOCGWINSZ, &ws)) {
25                         if (ws.ws_col)
26                                 return ws.ws_col;
27                 }
28         }
29 #endif
30
31         return 80;
32 }
33
34 static void oom(void)
35 {
36         fprintf(stderr, "git: out of memory\n");
37         exit(1);
38 }
39
40 static inline void mput_char(char c, unsigned int num)
41 {
42         while(num--)
43                 putchar(c);
44 }
45
46 static struct cmdname {
47         size_t len;
48         char name[1];
49 } **cmdname;
50 static int cmdname_alloc, cmdname_cnt;
51
52 static void add_cmdname(const char *name, int len)
53 {
54         struct cmdname *ent;
55         if (cmdname_alloc <= cmdname_cnt) {
56                 cmdname_alloc = cmdname_alloc + 200;
57                 cmdname = realloc(cmdname, cmdname_alloc * sizeof(*cmdname));
58                 if (!cmdname)
59                         oom();
60         }
61         ent = malloc(sizeof(*ent) + len);
62         if (!ent)
63                 oom();
64         ent->len = len;
65         memcpy(ent->name, name, len);
66         ent->name[len] = 0;
67         cmdname[cmdname_cnt++] = ent;
68 }
69
70 static int cmdname_compare(const void *a_, const void *b_)
71 {
72         struct cmdname *a = *(struct cmdname **)a_;
73         struct cmdname *b = *(struct cmdname **)b_;
74         return strcmp(a->name, b->name);
75 }
76
77 static void pretty_print_string_list(struct cmdname **cmdname, int longest)
78 {
79         int cols = 1, rows;
80         int space = longest + 1; /* min 1 SP between words */
81         int max_cols = term_columns() - 1; /* don't print *on* the edge */
82         int i, j;
83
84         if (space < max_cols)
85                 cols = max_cols / space;
86         rows = (cmdname_cnt + cols - 1) / cols;
87
88         qsort(cmdname, cmdname_cnt, sizeof(*cmdname), cmdname_compare);
89
90         for (i = 0; i < rows; i++) {
91                 printf("  ");
92
93                 for (j = 0; j < cols; j++) {
94                         int n = j * rows + i;
95                         int size = space;
96                         if (n >= cmdname_cnt)
97                                 break;
98                         if (j == cols-1 || n + rows >= cmdname_cnt)
99                                 size = 1;
100                         printf("%-*s", size, cmdname[n]->name);
101                 }
102                 putchar('\n');
103         }
104 }
105
106 static void list_commands(const char *exec_path, const char *pattern)
107 {
108         unsigned int longest = 0;
109         char path[PATH_MAX];
110         int dirlen;
111         DIR *dir = opendir(exec_path);
112         struct dirent *de;
113
114         if (!dir) {
115                 fprintf(stderr, "git: '%s': %s\n", exec_path, strerror(errno));
116                 exit(1);
117         }
118
119         dirlen = strlen(exec_path);
120         if (PATH_MAX - 20 < dirlen) {
121                 fprintf(stderr, "git: insanely long exec-path '%s'\n",
122                         exec_path);
123                 exit(1);
124         }
125
126         memcpy(path, exec_path, dirlen);
127         path[dirlen++] = '/';
128
129         while ((de = readdir(dir)) != NULL) {
130                 struct stat st;
131                 int entlen;
132
133                 if (strncmp(de->d_name, "git-", 4))
134                         continue;
135                 strcpy(path+dirlen, de->d_name);
136                 if (stat(path, &st) || /* stat, not lstat */
137                     !S_ISREG(st.st_mode) ||
138                     !(st.st_mode & S_IXUSR))
139                         continue;
140
141                 entlen = strlen(de->d_name);
142                 if (has_extension(de->d_name, ".exe"))
143                         entlen -= 4;
144
145                 if (longest < entlen)
146                         longest = entlen;
147
148                 add_cmdname(de->d_name + 4, entlen-4);
149         }
150         closedir(dir);
151
152         printf("git commands available in '%s'\n", exec_path);
153         printf("----------------------------");
154         mput_char('-', strlen(exec_path));
155         putchar('\n');
156         pretty_print_string_list(cmdname, longest - 4);
157         putchar('\n');
158 }
159
160 static void list_common_cmds_help(void)
161 {
162         int i, longest = 0;
163
164         for (i = 0; i < ARRAY_SIZE(common_cmds); i++) {
165                 if (longest < strlen(common_cmds[i].name))
166                         longest = strlen(common_cmds[i].name);
167         }
168
169         puts("The most commonly used git commands are:");
170         for (i = 0; i < ARRAY_SIZE(common_cmds); i++) {
171                 printf("    %s", common_cmds[i].name);
172                 mput_char(' ', longest - strlen(common_cmds[i].name) + 4);
173                 puts(common_cmds[i].help);
174         }
175         puts("(use 'git help -a' to get a list of all installed git commands)");
176 }
177
178 static void show_man_page(const char *git_cmd)
179 {
180         const char *page;
181
182         if (!strncmp(git_cmd, "git", 3))
183                 page = git_cmd;
184         else {
185                 int page_len = strlen(git_cmd) + 4;
186                 char *p = xmalloc(page_len + 1);
187                 strcpy(p, "git-");
188                 strcpy(p + 4, git_cmd);
189                 p[page_len] = 0;
190                 page = p;
191         }
192
193         execlp("man", "man", page, NULL);
194 }
195
196 void help_unknown_cmd(const char *cmd)
197 {
198         printf("git: '%s' is not a git-command\n\n", cmd);
199         list_common_cmds_help();
200         exit(1);
201 }
202
203 int cmd_version(int argc, const char **argv, const char *prefix)
204 {
205         printf("git version %s\n", git_version_string);
206         return 0;
207 }
208
209 int cmd_help(int argc, const char **argv, const char *prefix)
210 {
211         const char *help_cmd = argc > 1 ? argv[1] : NULL;
212         const char *exec_path = git_exec_path();
213
214         if (!help_cmd) {
215                 printf("usage: %s\n\n", git_usage_string);
216                 list_common_cmds_help();
217                 exit(1);
218         }
219
220         else if (!strcmp(help_cmd, "--all") || !strcmp(help_cmd, "-a")) {
221                 printf("usage: %s\n\n", git_usage_string);
222                 if(exec_path)
223                         list_commands(exec_path, "git-*");
224                 exit(1);
225         }
226
227         else
228                 show_man_page(help_cmd);
229
230         return 0;
231 }
232
233