4 files changed, 35 insertions, 8 deletions

diff --git a/cmd.c b/cmd.c
index 6dc9f5e..536515b 100644
--- a/cmd.c
+++ b/cmd.c
@@ -22,97 +22,98 @@
 #include "ui-repolist.h"
 #include "ui-snapshot.h"
 #include "ui-stats.h"
 #include "ui-summary.h"
 #include "ui-tag.h"
 #include "ui-tree.h"
 
 static void HEAD_fn(struct cgit_context *ctx)
 {
         cgit_clone_head(ctx);
 }
 
 static void atom_fn(struct cgit_context *ctx)
 {
         cgit_print_atom(ctx->qry.head, ctx->qry.path, ctx->cfg.max_atom_items);
 }
 
 static void about_fn(struct cgit_context *ctx)
 {
         if (ctx->repo)
                 cgit_print_repo_readme(ctx->qry.path);
         else
                 cgit_print_site_readme();
 }
 
 static void blob_fn(struct cgit_context *ctx)
 {
         cgit_print_blob(ctx->qry.sha1, ctx->qry.path, ctx->qry.head);
 }
 
 static void commit_fn(struct cgit_context *ctx)
 {
         cgit_print_commit(ctx->qry.sha1, ctx->qry.path);
 }
 
 static void diff_fn(struct cgit_context *ctx)
 {
         cgit_print_diff(ctx->qry.sha1, ctx->qry.sha2, ctx->qry.path);
 }
 
 static void info_fn(struct cgit_context *ctx)
 {
         cgit_clone_info(ctx);
 }
 
 static void log_fn(struct cgit_context *ctx)
 {
         cgit_print_log(ctx->qry.sha1, ctx->qry.ofs, ctx->cfg.max_commit_count,
-                       ctx->qry.grep, ctx->qry.search, ctx->qry.path, 1);
+                       ctx->qry.grep, ctx->qry.search, ctx->qry.path, 1,
+                       ctx->repo->enable_commit_graph);
 }
 
 static void ls_cache_fn(struct cgit_context *ctx)
 {
         ctx->page.mimetype = "text/plain";
         ctx->page.filename = "ls-cache.txt";
         cgit_print_http_headers(ctx);
         cache_ls(ctx->cfg.cache_root);
 }
 
 static void objects_fn(struct cgit_context *ctx)
 {
         cgit_clone_objects(ctx);
 }
 
 static void repolist_fn(struct cgit_context *ctx)
 {
         cgit_print_repolist();
 }
 
 static void patch_fn(struct cgit_context *ctx)
 {
         cgit_print_patch(ctx->qry.sha1, ctx->qry.path);
 }
 
 static void plain_fn(struct cgit_context *ctx)
 {
         cgit_print_plain(ctx);
 }
 
 static void refs_fn(struct cgit_context *ctx)
 {
         cgit_print_refs();
 }
 
 static void snapshot_fn(struct cgit_context *ctx)
 {
         cgit_print_snapshot(ctx->qry.head, ctx->qry.sha1, ctx->qry.path,
                             ctx->repo->snapshots, ctx->qry.nohead);
 }
 
 static void stats_fn(struct cgit_context *ctx)
 {
         cgit_show_stats(ctx);
 }
 
 static void summary_fn(struct cgit_context *ctx)
 {
diff --git a/ui-log.c b/ui-log.c
index 5cf66cb..05b5c29 100644
--- a/ui-log.c
+++ b/ui-log.c
@@ -53,320 +53,345 @@ void inspect_files(struct diff_filepair *pair)
                                 count_lines);
 }
 
 void show_commit_decorations(struct commit *commit)
 {
         struct name_decoration *deco;
         static char buf[1024];
 
         buf[sizeof(buf) - 1] = 0;
         deco = lookup_decoration(&name_decoration, &commit->object);
         while (deco) {
                 if (!prefixcmp(deco->name, "refs/heads/")) {
                         strncpy(buf, deco->name + 11, sizeof(buf) - 1);
                         cgit_log_link(buf, NULL, "branch-deco", buf, NULL,
                                       ctx.qry.vpath, 0, NULL, NULL,
                                       ctx.qry.showmsg);
                 }
                 else if (!prefixcmp(deco->name, "tag: refs/tags/")) {
                         strncpy(buf, deco->name + 15, sizeof(buf) - 1);
                         cgit_tag_link(buf, NULL, "tag-deco", ctx.qry.head, buf);
                 }
                 else if (!prefixcmp(deco->name, "refs/tags/")) {
                         strncpy(buf, deco->name + 10, sizeof(buf) - 1);
                         cgit_tag_link(buf, NULL, "tag-deco", ctx.qry.head, buf);
                 }
                 else if (!prefixcmp(deco->name, "refs/remotes/")) {
                         strncpy(buf, deco->name + 13, sizeof(buf) - 1);
                         cgit_log_link(buf, NULL, "remote-deco", NULL,
                                       sha1_to_hex(commit->object.sha1),
                                       ctx.qry.vpath, 0, NULL, NULL,
                                       ctx.qry.showmsg);
                 }
                 else {
                         strncpy(buf, deco->name, sizeof(buf) - 1);
                         cgit_commit_link(buf, NULL, "deco", ctx.qry.head,
                                          sha1_to_hex(commit->object.sha1),
                                          ctx.qry.vpath, 0);
                 }
                 deco = deco->next;
         }
 }
 
 void print_commit(struct commit *commit, struct rev_info *revs)
 {
         struct commitinfo *info;
         char *tmp;
         int cols = 2;
         struct strbuf graphbuf = STRBUF_INIT;
+        struct strbuf msgbuf = STRBUF_INIT;
 
         if (ctx.repo->enable_log_filecount) {
                 cols++;
                 if (ctx.repo->enable_log_linecount)
                         cols++;
         }
 
         if (revs->graph) {
                 /* Advance graph until current commit */
                 while (!graph_next_line(revs->graph, &graphbuf)) {
                         /* Print graph segment in otherwise empty table row */
                         html("<tr class='nohover'><td/><td class='commitgraph'>");
                         html(graphbuf.buf);
                         htmlf("</td><td colspan='%d' /></tr>\n", cols);
                         strbuf_setlen(&graphbuf, 0);
                 }
                 /* Current commit's graph segment is now ready in graphbuf */
         }
 
         info = cgit_parse_commit(commit);
         htmlf("<tr%s><td>",
                 ctx.qry.showmsg ? " class='logheader'" : "");
         tmp = fmt("id=%s", sha1_to_hex(commit->object.sha1));
         tmp = cgit_fileurl(ctx.repo->url, "commit", ctx.qry.vpath, tmp);
         html_link_open(tmp, NULL, NULL);
         cgit_print_age(commit->date, TM_WEEK * 2, FMT_SHORTDATE);
         html_link_close();
         html("</td>");
 
         if (revs->graph) {
                 /* Print graph segment for current commit */
                 html("<td class='commitgraph'>");
                 html(graphbuf.buf);
                 html("</td>");
                 strbuf_setlen(&graphbuf, 0);
         }
 
         htmlf("<td%s>", ctx.qry.showmsg ? " class='logsubject'" : "");
+        if (ctx.qry.showmsg) {
+                /* line-wrap long commit subjects instead of truncating them */
+                size_t subject_len = strlen(info->subject);
+
+                if (subject_len > ctx.cfg.max_msg_len &&
+                    ctx.cfg.max_msg_len >= 15) {
+                        /* symbol for signaling line-wrap (in PAGE_ENCODING) */
+                        const char wrap_symbol[] = { ' ', 0xE2, 0x86, 0xB5, 0 };
+                        int i = ctx.cfg.max_msg_len - strlen(wrap_symbol);
+
+                        /* Rewind i to preceding space character */
+                        while (i > 0 && !isspace(info->subject[i]))
+                                --i;
+                        if (!i) /* Oops, zero spaces. Reset i */
+                                i = ctx.cfg.max_msg_len - strlen(wrap_symbol);
+
+                        /* add remainder starting at i to msgbuf */
+                        strbuf_add(&msgbuf, info->subject + i, subject_len - i);
+                        strbuf_trim(&msgbuf);
+                        strbuf_add(&msgbuf, "\n\n", 2);
+
+                        /* Place wrap_symbol at position i in info->subject */
+                        strcpy(info->subject + i, wrap_symbol);
+                }
+        }
         cgit_commit_link(info->subject, NULL, NULL, ctx.qry.head,
                          sha1_to_hex(commit->object.sha1), ctx.qry.vpath, 0);
         show_commit_decorations(commit);
         html("</td><td>");
         html_txt(info->author);
         if (ctx.repo->enable_log_filecount) {
                 files = 0;
                 add_lines = 0;
                 rem_lines = 0;
                 cgit_diff_commit(commit, inspect_files, ctx.qry.vpath);
                 html("</td><td>");
                 htmlf("%d", files);
                 if (ctx.repo->enable_log_linecount) {
                         html("</td><td>");
                         htmlf("-%d/+%d", rem_lines, add_lines);
                 }
         }
         html("</td></tr>\n");
 
         if (revs->graph || ctx.qry.showmsg) { /* Print a second table row */
-                struct strbuf msgbuf = STRBUF_INIT;
                 html("<tr class='nohover'><td/>"); /* Empty 'Age' column */
 
                 if (ctx.qry.showmsg) {
                         /* Concatenate commit message + notes in msgbuf */
                         if (info->msg && *(info->msg)) {
                                 strbuf_addstr(&msgbuf, info->msg);
                                 strbuf_addch(&msgbuf, '\n');
                         }
                         format_note(NULL, commit->object.sha1, &msgbuf,
                                     PAGE_ENCODING,
                                     NOTES_SHOW_HEADER | NOTES_INDENT);
                         strbuf_addch(&msgbuf, '\n');
                         strbuf_ltrim(&msgbuf);
                 }
 
                 if (revs->graph) {
                         int lines = 0;
 
                         /* Calculate graph padding */
                         if (ctx.qry.showmsg) {
                                 /* Count #lines in commit message + notes */
                                 const char *p = msgbuf.buf;
                                 lines = 1;
                                 while ((p = strchr(p, '\n'))) {
                                         p++;
                                         lines++;
                                 }
                         }
 
                         /* Print graph padding */
                         html("<td class='commitgraph'>");
                         while (lines > 0 || !graph_is_commit_finished(revs->graph)) {
                                 if (graphbuf.len)
                                         html("\n");
                                 strbuf_setlen(&graphbuf, 0);
                                 graph_next_line(revs->graph, &graphbuf);
                                 html(graphbuf.buf);
                                 lines--;
                         }
                         html("</td>\n");
                 }
 
                 /* Print msgbuf into remainder of table row */
                 htmlf("<td colspan='%d'%s>\n", cols,
                         ctx.qry.showmsg ? " class='logmsg'" : "");
                 html_txt(msgbuf.buf);
                 html("</td></tr>\n");
-                strbuf_release(&msgbuf);
         }
 
+        strbuf_release(&msgbuf);
         strbuf_release(&graphbuf);
         cgit_free_commitinfo(info);
 }
 
 static const char *disambiguate_ref(const char *ref)
 {
         unsigned char sha1[20];
         const char *longref;
 
         longref = fmt("refs/heads/%s", ref);
         if (get_sha1(longref, sha1) == 0)
                 return longref;
 
         return ref;
 }
 
 static char *next_token(char **src)
 {
         char *result;
 
         if (!src || !*src)
                 return NULL;
         while (isspace(**src))
                 (*src)++;
         if (!**src)
                 return NULL;
         result = *src;
         while (**src) {
                 if (isspace(**src)) {
                         **src = '\0';
                         (*src)++;
                         break;
                 }
                 (*src)++;
         }
         return result;
 }
 
 void cgit_print_log(const char *tip, int ofs, int cnt, char *grep, char *pattern,
-                    char *path, int pager)
+                    char *path, int pager, int commit_graph)
 {
         struct rev_info rev;
         struct commit *commit;
         struct vector vec = VECTOR_INIT(char *);
         int i, columns = 3;
         char *arg;
 
         /* First argv is NULL */
         vector_push(&vec, NULL, 0);
 
         if (!tip)
                 tip = ctx.qry.head;
         tip = disambiguate_ref(tip);
         vector_push(&vec, &tip, 0);
 
         if (grep && pattern && *pattern) {
                 pattern = xstrdup(pattern);
                 if (!strcmp(grep, "grep") || !strcmp(grep, "author") ||
                     !strcmp(grep, "committer")) {
                         arg = fmt("--%s=%s", grep, pattern);
                         vector_push(&vec, &arg, 0);
                 }
                 if (!strcmp(grep, "range")) {
                         /* Split the pattern at whitespace and add each token
                          * as a revision expression. Do not accept other
                          * rev-list options. Also, replace the previously
                          * pushed tip (it's no longer relevant).
                          */
                         vec.count--;
                         while ((arg = next_token(&pattern))) {
                                 if (*arg == '-') {
                                         fprintf(stderr, "Bad range expr: %s\n",
                                                 arg);
                                         break;
                                 }
                                 vector_push(&vec, &arg, 0);
                         }
                 }
         }
-        if (ctx.repo->enable_commit_graph) {
+        if (commit_graph) {
                 static const char *graph_arg = "--graph";
                 static const char *color_arg = "--color";
                 vector_push(&vec, &graph_arg, 0);
                 vector_push(&vec, &color_arg, 0);
                 graph_set_column_colors(column_colors_html,
                                         COLUMN_COLORS_HTML_MAX);
         }
 
         if (path) {
                 arg = "--";
                 vector_push(&vec, &arg, 0);
                 vector_push(&vec, &path, 0);
         }
 
         /* Make sure the vector is NULL-terminated */
         vector_push(&vec, NULL, 0);
         vec.count--;
 
         init_revisions(&rev, NULL);
         rev.abbrev = DEFAULT_ABBREV;
         rev.commit_format = CMIT_FMT_DEFAULT;
         rev.verbose_header = 1;
         rev.show_root_diff = 0;
         setup_revisions(vec.count, vec.data, &rev, NULL);
         load_ref_decorations(DECORATE_FULL_REFS);
         rev.show_decorations = 1;
         rev.grep_filter.regflags |= REG_ICASE;
         compile_grep_patterns(&rev.grep_filter);
         prepare_revision_walk(&rev);
 
         if (pager)
                 html("<table class='list nowrap'>");
 
         html("<tr class='nohover'><th class='left'>Age</th>");
-        if (ctx.repo->enable_commit_graph)
+        if (commit_graph)
                 html("<th></th>");
         html("<th class='left'>Commit message");
         if (pager) {
                 html(" (");
                 cgit_log_link(ctx.qry.showmsg ? "Collapse" : "Expand", NULL,
                               NULL, ctx.qry.head, ctx.qry.sha1,
                               ctx.qry.vpath, ctx.qry.ofs, ctx.qry.grep,
                               ctx.qry.search, ctx.qry.showmsg ? 0 : 1);
                 html(")");
         }
         html("</th><th class='left'>Author</th>");
         if (ctx.repo->enable_log_filecount) {
                 html("<th class='left'>Files</th>");
                 columns++;
                 if (ctx.repo->enable_log_linecount) {
                         html("<th class='left'>Lines</th>");
                         columns++;
                 }
         }
         html("</tr>\n");
 
         if (ofs<0)
                 ofs = 0;
 
         for (i = 0; i < ofs && (commit = get_revision(&rev)) != NULL; i++) {
                 free(commit->buffer);
                 commit->buffer = NULL;
                 free_commit_list(commit->parents);
                 commit->parents = NULL;
         }
 
         for (i = 0; i < cnt && (commit = get_revision(&rev)) != NULL; i++) {
                 print_commit(commit, &rev);
                 free(commit->buffer);
                 commit->buffer = NULL;
                 free_commit_list(commit->parents);
                 commit->parents = NULL;
         }
         if (pager) {
                 html("</table><div class='pager'>");
                 if (ofs > 0) {
                         cgit_log_link("[prev]", NULL, NULL, ctx.qry.head,
                                       ctx.qry.sha1, ctx.qry.vpath,
                                       ofs - cnt, ctx.qry.grep,
                                       ctx.qry.search, ctx.qry.showmsg);
                         html("&nbsp;");
                 }
                 if ((commit = get_revision(&rev)) != NULL) {
diff --git a/ui-log.h b/ui-log.h
index 6034055..d0cb779 100644
--- a/ui-log.h
+++ b/ui-log.h
@@ -1,8 +1,9 @@
 #ifndef UI_LOG_H
 #define UI_LOG_H
 
 extern void cgit_print_log(const char *tip, int ofs, int cnt, char *grep,
-                           char *pattern, char *path, int pager);
+                           char *pattern, char *path, int pager,
+                           int commit_graph);
 extern void show_commit_decorations(struct commit *commit);
 
 #endif /* UI_LOG_H */
diff --git a/ui-summary.c b/ui-summary.c
index b203bcc..5be2545 100644
--- a/ui-summary.c
+++ b/ui-summary.c
@@ -14,97 +14,97 @@
 #include "ui-blob.h"
 
 int urls = 0;
 
 static void print_url(char *base, char *suffix)
 {
         if (!base || !*base)
                 return;
         if (urls++ == 0) {
                 html("<tr class='nohover'><td colspan='4'>&nbsp;</td></tr>");
                 html("<tr><th class='left' colspan='4'>Clone</th></tr>\n");
         }
         if (suffix && *suffix)
                 base = fmt("%s/%s", base, suffix);
         html("<tr><td colspan='4'><a href='");
         html_url_path(base);
         html("'>");
         html_txt(base);
         html("</a></td></tr>\n");
 }
 
 static void print_urls(char *txt, char *suffix)
 {
         char *h = txt, *t, c;
 
         while (h && *h) {
                 while (h && *h == ' ')
                         h++;
                 t = h;
                 while (t && *t && *t != ' ')
                         t++;
                 c = *t;
                 *t = 0;
                 print_url(h, suffix);
                 *t = c;
                 h = t;
         }
 }
 
 void cgit_print_summary()
 {
         html("<table summary='repository info' class='list nowrap'>");
         cgit_print_branches(ctx.cfg.summary_branches);
         html("<tr class='nohover'><td colspan='4'>&nbsp;</td></tr>");
         cgit_print_tags(ctx.cfg.summary_tags);
         if (ctx.cfg.summary_log > 0) {
                 html("<tr class='nohover'><td colspan='4'>&nbsp;</td></tr>");
                 cgit_print_log(ctx.qry.head, 0, ctx.cfg.summary_log, NULL,
-                               NULL, NULL, 0);
+                               NULL, NULL, 0, 0);
         }
         if (ctx.repo->clone_url)
                 print_urls(ctx.repo->clone_url, NULL);
         else if (ctx.cfg.clone_prefix)
                 print_urls(ctx.cfg.clone_prefix, ctx.repo->url);
         html("</table>");
 }
 
 void cgit_print_repo_readme(char *path)
 {
         char *slash, *tmp, *colon, *ref;
 
         if (!ctx.repo->readme || !(*ctx.repo->readme))
                 return;
 
         ref = NULL;
 
         /* Check if the readme is tracked in the git repo. */
         colon = strchr(ctx.repo->readme, ':');
         if (colon && strlen(colon) > 1) {
                 *colon = '\0';
                 ref = ctx.repo->readme;
                 ctx.repo->readme = colon + 1;
                 if (!(*ctx.repo->readme))
                         return;
         }
 
         /* Prepend repo path to relative readme path unless tracked. */
         if (!ref && *ctx.repo->readme != '/')
                 ctx.repo->readme = xstrdup(fmt("%s/%s", ctx.repo->path,
                                                ctx.repo->readme));
 
         /* If a subpath is specified for the about page, make it relative
          * to the directory containing the configured readme.
          */
         if (path) {
                 slash = strrchr(ctx.repo->readme, '/');
                 if (!slash) {
                         if (!colon)
                                 return;
                         slash = colon;
                 }
                 tmp = xmalloc(slash - ctx.repo->readme + 1 + strlen(path) + 1);
                 strncpy(tmp, ctx.repo->readme, slash - ctx.repo->readme + 1);
                 strcpy(tmp + (slash - ctx.repo->readme + 1), path);
         } else
                 tmp = ctx.repo->readme;