]> Sergey Matveev's repositories - public-inbox.git/blob - lib/PublicInbox/View.pm
ee5ba20e2a91e7b15dfd1ae6e3243fad167ba294
[public-inbox.git] / lib / PublicInbox / View.pm
1 # Copyright (C) 2014, Eric Wong <normalperson@yhbt.net> and all contributors
2 # License: AGPLv3 or later (https://www.gnu.org/licenses/agpl-3.0.txt)
3 package PublicInbox::View;
4 use strict;
5 use warnings;
6 use URI::Escape qw/uri_escape_utf8/;
7 use Date::Parse qw/str2time/;
8 use Encode qw/find_encoding/;
9 use Encode::MIME::Header;
10 use Email::MIME::ContentType qw/parse_content_type/;
11 use PublicInbox::Hval;
12 use PublicInbox::MID qw/mid_clean mid_compress mid2path/;
13 use Digest::SHA qw/sha1_hex/;
14 my $SALT = rand;
15 require POSIX;
16
17 # TODO: make these constants tunable
18 use constant MAX_INLINE_QUOTED => 12; # half an 80x24 terminal
19 use constant MAX_TRUNC_LEN => 72;
20 use constant PRE_WRAP => "<pre\nstyle=\"white-space:pre-wrap\">";
21 use constant T_ANCHOR => '#u';
22 use constant INDENT => '  ';
23
24 *ascii_html = *PublicInbox::Hval::ascii_html;
25
26 my $enc_utf8 = find_encoding('UTF-8');
27
28 # public functions:
29 sub msg_html {
30         my ($ctx, $mime, $full_pfx, $footer) = @_;
31         if (defined $footer) {
32                 $footer = "\n" . $footer;
33         } else {
34                 $footer = '';
35         }
36         headers_to_html_header($mime, $full_pfx, $ctx) .
37                 multipart_text_as_html($mime, $full_pfx) .
38                 '</pre><hr />' . PRE_WRAP .
39                 html_footer($mime, 1, $full_pfx, $ctx) .
40                 $footer .
41                 '</pre></body></html>';
42 }
43
44 sub feed_entry {
45         my ($class, $mime, $full_pfx) = @_;
46
47         PRE_WRAP . multipart_text_as_html($mime, $full_pfx) . '</pre>';
48 }
49
50 sub in_reply_to {
51         my ($header_obj) = @_;
52         my $irt = $header_obj->header('In-Reply-To');
53
54         return mid_clean($irt) if (defined $irt);
55
56         my $refs = $header_obj->header('References');
57         if ($refs && $refs =~ /<([^>]+)>\s*\z/s) {
58                 return $1;
59         }
60         undef;
61 }
62
63 # this is already inside a <pre>
64 sub index_entry {
65         my ($fh, $mime, $level, $state) = @_;
66         my $midx = $state->{anchor_idx}++;
67         my $ctx = $state->{ctx};
68         my $srch = $ctx->{srch};
69         my ($prev, $next) = ($midx - 1, $midx + 1);
70         my $part_nr = 0;
71         my $enc = enc_for($mime->header("Content-Type"));
72         my $subj = $mime->header('Subject');
73         my $header_obj = $mime->header_obj;
74
75         my $mid_raw = $header_obj->header('Message-ID');
76         my $id = anchor_for($mid_raw);
77         my $seen = $state->{seen};
78         $seen->{$id} = "#$id"; # save the anchor for children, later
79
80         my $mid = PublicInbox::Hval->new_msgid($mid_raw);
81         my $from = PublicInbox::Hval->new_oneline($mime->header('From'))->raw;
82         my @from = Email::Address->parse($from);
83         $from = $from[0]->name;
84
85         $from = PublicInbox::Hval->new_oneline($from)->as_html;
86         $subj = PublicInbox::Hval->new_oneline($subj)->as_html;
87         my $more = 'permalink';
88         my $root_anchor = $state->{root_anchor};
89         my $path = $root_anchor ? '../../' : '';
90         my $href = $mid->as_href;
91         my $irt = in_reply_to($header_obj);
92         my $parent_anchor = $seen->{anchor_for($irt)} if defined $irt;
93
94         if ($srch) {
95                 my $t = $ctx->{flat} ? 'T' : 't';
96                 $subj = "<a\nhref=\"${path}$href/$t/#u\">$subj</a>";
97         }
98         if ($root_anchor && $root_anchor eq $id) {
99                 $subj = "<u\nid=\"u\">$subj</u>";
100         }
101
102         my $ts = _msg_date($mime);
103         my $rv = "<table\nsummary=l$level><tr>";
104         if ($level) {
105                 $rv .= '<td><pre>' . (INDENT x $level) . '</pre></td>';
106         }
107         $rv .= "<td\nid=s$midx>" . PRE_WRAP;
108         $rv .= "<b\nid=\"$id\">$subj</b>\n";
109         $rv .= "- by $from @ $ts UTC - ";
110         $rv .= "<a\nhref=\"#s$next\">next</a>";
111         if ($prev >= 0) {
112                 $rv .= "/<a\nhref=\"#s$prev\">prev</a>";
113         }
114         $fh->write($rv .= "\n\n");
115
116         my ($fhref, $more_ref);
117         my $mhref = "${path}$href/";
118
119         # show full messages at level == 0 in threaded view
120         if ($level > 0 || ($ctx->{flat} && $root_anchor ne $id)) {
121                 $fhref = "${path}$href/f/";
122                 $more_ref = \$more;
123         }
124         # scan through all parts, looking for displayable text
125         $mime->walk_parts(sub {
126                 index_walk($fh, $_[0], $enc, \$part_nr, $fhref, $more_ref);
127         });
128         $mime->body_set('');
129
130         my $txt = "${path}$href/raw";
131         $rv = "\n<a\nhref=\"$mhref\">$more</a> <a\nhref=\"$txt\">raw</a> ";
132         $rv .= html_footer($mime, 0, undef, $ctx);
133
134         if (defined $irt) {
135                 unless (defined $parent_anchor) {
136                         my $v = PublicInbox::Hval->new_msgid($irt, 1);
137                         $v = $v->as_href;
138                         $parent_anchor = "${path}$v/";
139                 }
140                 $rv .= " <a\nhref=\"$parent_anchor\">parent</a>";
141         }
142         if ($srch) {
143                 if ($ctx->{flat}) {
144                         $rv .= " [<a\nhref=\"${path}$href/t/#u\">threaded</a>" .
145                                 "|<b>flat</b>]";
146                 } else {
147                         $rv .= " [<b>threaded</b>|" .
148                                 "<a\nhref=\"${path}$href/T/#u\">flat</a>]";
149                 }
150         }
151
152         $fh->write($rv .= '</pre></td></tr></table>');
153 }
154
155 sub thread_html {
156         my ($ctx, $foot, $srch) = @_;
157         sub { emit_thread_html($_[0], $ctx, $foot, $srch) }
158 }
159
160 # only private functions below.
161
162 sub emit_thread_html {
163         my ($cb, $ctx, $foot, $srch) = @_;
164         my $mid = $ctx->{mid};
165         my $res = $srch->get_thread($mid);
166         my $msgs = load_results($res);
167         my $nr = scalar @$msgs;
168         return missing_thread($cb, $ctx) if $nr == 0;
169         my $flat = $ctx->{flat};
170         my $orig_cb = $cb;
171         my $seen = {};
172         my $state = {
173                 ctx => $ctx,
174                 seen => $seen,
175                 root_anchor => anchor_for($mid),
176                 anchor_idx => 0,
177         };
178
179         require PublicInbox::GitCatFile;
180         my $git = PublicInbox::GitCatFile->new($ctx->{git_dir});
181         if ($flat) {
182                 pre_anchor_entry($seen, $_) for (@$msgs);
183                 __thread_entry(\$cb, $git, $state, $_, 0) for (@$msgs);
184         } else {
185                 my $th = thread_results($msgs);
186                 thread_entry(\$cb, $git, $state, $_, 0) for $th->rootset;
187         }
188         $git = undef;
189         Email::Address->purge_cache;
190
191         # there could be a race due to a message being deleted in git
192         # but still being in the Xapian index:
193         return missing_thread($cb, $ctx) if ($orig_cb eq $cb);
194
195         my $final_anchor = $state->{anchor_idx};
196         my $next = "<a\nid=\"s$final_anchor\">";
197         $next .= $final_anchor == 1 ? 'only message in' : 'end of';
198         $next .= " thread</a>, back to <a\nhref=\"../../\">index</a>";
199         if ($flat) {
200                 $next .= " [<a\nhref=\"../t/#u\">threaded</a>|<b>flat</b>]";
201         } else {
202                 $next .= " [<b>threaded</b>|<a\nhref=\"../T/#u\">flat</a>]";
203         }
204         $next .= "\ndownload thread: <a\nhref=\"../t.mbox.gz\">mbox.gz</a>";
205         $next .= " / follow: <a\nhref=\"../t.atom\">Atom feed</a>";
206         $cb->write("<hr />" . PRE_WRAP . $next . "\n\n". $foot .
207                    "</pre></body></html>");
208         $cb->close;
209 }
210
211 sub index_walk {
212         my ($fh, $part, $enc, $part_nr, $fhref, $more) = @_;
213         my $s = add_text_body($enc, $part, $part_nr, $fhref);
214
215         if ($more) {
216                 # drop the remainder of git patches, they're usually better
217                 # to review when the full message is viewed
218                 $s =~ s!^---+\n.*\z!!ms and $$more = 'more...';
219
220                 # Drop signatures
221                 $s =~ s/^-- \n.*\z//ms and $$more = 'more...';
222         }
223
224         # kill any leading or trailing whitespace lines
225         $s =~ s/^\s*$//sgm;
226         $s =~ s/\s+\z//s;
227
228         if ($s ne '') {
229                 # kill per-line trailing whitespace
230                 $s =~ s/[ \t]+$//sgm;
231                 $s .= "\n" unless $s =~ /\n\z/s;
232         }
233         $fh->write($s);
234 }
235
236 sub enc_for {
237         my ($ct, $default) = @_;
238         $default ||= $enc_utf8;
239         defined $ct or return $default;
240         my $ct_parsed = parse_content_type($ct);
241         if ($ct_parsed) {
242                 if (my $charset = $ct_parsed->{attributes}->{charset}) {
243                         my $enc = find_encoding($charset);
244                         return $enc if $enc;
245                 }
246         }
247         $default;
248 }
249
250 sub multipart_text_as_html {
251         my ($mime, $full_pfx, $srch) = @_;
252         my $rv = "";
253         my $part_nr = 0;
254         my $enc = enc_for($mime->header("Content-Type"));
255
256         # scan through all parts, looking for displayable text
257         $mime->walk_parts(sub {
258                 my ($part) = @_;
259                 $rv .= add_text_body($enc, $part, \$part_nr, $full_pfx);
260         });
261         $mime->body_set('');
262         $rv;
263 }
264
265 sub add_filename_line {
266         my ($enc, $fn) = @_;
267         my $len = 72;
268         my $pad = "-";
269         $fn = $enc->decode($fn);
270         $len -= length($fn);
271         $pad x= ($len/2) if ($len > 0);
272         "$pad " . ascii_html($fn) . " $pad\n";
273 }
274
275 my $LINK_RE = qr!\b((?:ftp|https?|nntp)://
276                  [\@:\w\.-]+/
277                  ?[\@\w\+\&\?\.\%\;/#=-]*)!x;
278
279 sub linkify_1 {
280         my ($link_map, $s) = @_;
281         $s =~ s!$LINK_RE!
282                 my $url = $1;
283                 # salt this, as this could be exploited to show
284                 # links in the HTML which don't show up in the raw mail.
285                 my $key = sha1_hex($url . $SALT);
286                 $link_map->{$key} = $url;
287                 'PI-LINK-'. $key;
288         !ge;
289         $s;
290 }
291
292 sub linkify_2 {
293         my ($link_map, $s) = @_;
294
295         # Added "PI-LINK-" prefix to avoid false-positives on git commits
296         $s =~ s!\bPI-LINK-([a-f0-9]{40})\b!
297                 my $key = $1;
298                 my $url = $link_map->{$key};
299                 if (defined $url) {
300                         $url = ascii_html($url);
301                         "<a\nhref=\"$url\">$url</a>";
302                 } else {
303                         # false positive or somebody tried to mess with us
304                         $key;
305                 }
306         !ge;
307         $s;
308 }
309
310 sub flush_quote {
311         my ($quot, $n, $part_nr, $full_pfx, $final) = @_;
312
313         if ($full_pfx) {
314                 if (!$final && scalar(@$quot) <= MAX_INLINE_QUOTED) {
315                         # show quote inline
316                         my %l;
317                         my $rv = join('', map { linkify_1(\%l, $_) } @$quot);
318                         @$quot = ();
319                         $rv = ascii_html($rv);
320                         return linkify_2(\%l, $rv);
321                 }
322
323                 # show a short snippet of quoted text and link to full version:
324                 @$quot = map { s/^(?:>\s*)+//gm; $_ } @$quot;
325                 my $cur = join(' ', @$quot);
326                 @$quot = split(/\s+/, $cur);
327                 $cur = '';
328                 do {
329                         my $tmp = shift(@$quot);
330                         my $len = length($tmp) + length($cur);
331                         if ($len > MAX_TRUNC_LEN) {
332                                 @$quot = ();
333                         } else {
334                                 $cur .= $tmp . ' ';
335                         }
336                 } while (@$quot && length($cur) < MAX_TRUNC_LEN);
337                 @$quot = ();
338                 $cur =~ s/ \z/ .../s;
339                 $cur = ascii_html($cur);
340                 my $nr = ++$$n;
341                 "&gt; [<a\nhref=\"$full_pfx#q${part_nr}_$nr\">$cur</a>]\n";
342         } else {
343                 # show everything in the full version with anchor from
344                 # short version (see above)
345                 my $nr = ++$$n;
346                 my $rv = "";
347                 my %l;
348                 $rv .= join('', map { linkify_1(\%l, $_) } @$quot);
349                 @$quot = ();
350                 $rv = ascii_html($rv);
351                 "<a\nid=q${part_nr}_$nr></a>" . linkify_2(\%l, $rv);
352         }
353 }
354
355 sub add_text_body {
356         my ($enc_msg, $part, $part_nr, $full_pfx) = @_;
357         return '' if $part->subparts;
358
359         my $ct = $part->content_type;
360         # account for filter bugs...
361         if (defined $ct && $ct =~ m!\btext/[xh]+tml\b!i) {
362                 $part->body_set('');
363                 return '';
364         }
365         my $enc = enc_for($ct, $enc_msg);
366         my $n = 0;
367         my $nr = 0;
368         my $s = $part->body;
369         $part->body_set('');
370         $s = $enc->decode($s);
371         my @lines = split(/^/m, $s);
372         $s = '';
373
374         if ($$part_nr > 0) {
375                 my $fn = $part->filename;
376                 defined($fn) or $fn = "part #" . ($$part_nr + 1);
377                 $s .= add_filename_line($enc, $fn);
378         }
379
380         my @quot;
381         while (defined(my $cur = shift @lines)) {
382                 if ($cur !~ /^>/) {
383                         # show the previously buffered quote inline
384                         if (scalar @quot) {
385                                 $s .= flush_quote(\@quot, \$n, $$part_nr,
386                                                   $full_pfx, 0);
387                         }
388
389                         # regular line, OK
390                         my %l;
391                         $cur = linkify_1(\%l, $cur);
392                         $cur = ascii_html($cur);
393                         $s .= linkify_2(\%l, $cur);
394                 } else {
395                         push @quot, $cur;
396                 }
397         }
398         $s .= flush_quote(\@quot, \$n, $$part_nr, $full_pfx, 1) if scalar @quot;
399         $s .= "\n" unless $s =~ /\n\z/s;
400         ++$$part_nr;
401         $s;
402 }
403
404 sub headers_to_html_header {
405         my ($mime, $full_pfx, $ctx) = @_;
406         my $srch = $ctx->{srch} if $ctx;
407         my $rv = "";
408         my @title;
409         my $header_obj = $mime->header_obj;
410         my $mid = $header_obj->header('Message-ID');
411         $mid = PublicInbox::Hval->new_msgid($mid);
412         my $mid_href = $mid->as_href;
413         foreach my $h (qw(From To Cc Subject Date)) {
414                 my $v = $mime->header($h);
415                 defined($v) && ($v ne '') or next;
416                 $v = PublicInbox::Hval->new_oneline($v);
417
418                 if ($h eq 'From') {
419                         my @from = Email::Address->parse($v->raw);
420                         $title[1] = ascii_html($from[0]->name);
421                 } elsif ($h eq 'Subject') {
422                         $title[0] = $v->as_html;
423                         if ($srch) {
424                                 my $p = $full_pfx ? '' : '../';
425                                 $rv .= "$h: <a\nid=\"t\"\nhref=\"${p}t/#u\">";
426                                 $rv .= $v->as_html . "</a>\n";
427                                 next;
428                         }
429                 }
430                 $rv .= "$h: " . $v->as_html . "\n";
431
432         }
433         $rv .= 'Message-ID: &lt;' . $mid->as_html . '&gt; ';
434         my $raw_ref = $full_pfx ? 'raw' : '../raw';
435         $rv .= "(<a\nhref=\"$raw_ref\">raw</a>)\n";
436         if ($srch) {
437                 $rv .= "<a\nhref=\"#r\">References: [see below]</a>\n";
438         } else {
439                 $rv .= _parent_headers_nosrch($header_obj);
440         }
441         $rv .= "\n";
442
443         ("<html><head><title>".  join(' - ', @title) .
444          '</title></head><body>' . PRE_WRAP . $rv);
445 }
446
447 sub thread_inline {
448         my ($dst, $ctx, $cur, $full_pfx) = @_;
449         my $srch = $ctx->{srch};
450         my $mid = mid_clean($cur->header('Message-ID'));
451         my $res = $srch->get_thread($mid);
452         my $nr = $res->{total};
453
454         if ($nr <= 1) {
455                 $$dst .= "\n[no followups, yet]\n";
456                 return (undef, in_reply_to($cur));
457         }
458         my $upfx = $full_pfx ? '' : '../';
459
460         $$dst .= "\n\n~$nr messages in thread: ".
461                  "(<a\nhref=\"${upfx}t/#u\">expand</a>)\n";
462         my $subj = $srch->subject_path($cur->header('Subject'));
463         my $parent = in_reply_to($cur);
464         my $state = {
465                 seen => { $subj => 1 },
466                 srch => $srch,
467                 cur => $mid,
468                 parent_cmp => defined $parent ? $parent : '',
469                 parent => $parent,
470         };
471         for (thread_results(load_results($res))->rootset) {
472                 inline_dump($dst, $state, $upfx, $_, 0);
473         }
474         ($state->{next_msg}, $state->{parent});
475 }
476
477 sub _parent_headers_nosrch {
478         my ($header_obj) = @_;
479         my $rv = '';
480
481         my $irt = in_reply_to($header_obj);
482         if (defined $irt) {
483                 my $v = PublicInbox::Hval->new_msgid($irt, 1);
484                 my $html = $v->as_html;
485                 my $href = $v->as_href;
486                 $rv .= "In-Reply-To: &lt;";
487                 $rv .= "<a\nhref=\"../$href/\">$html</a>&gt;\n";
488         }
489
490         my $refs = $header_obj->header('References');
491         if ($refs) {
492                 # avoid redundant URLs wasting bandwidth
493                 my %seen;
494                 $seen{$irt} = 1 if defined $irt;
495                 my @refs;
496                 my @raw_refs = ($refs =~ /<([^>]+)>/g);
497                 foreach my $ref (@raw_refs) {
498                         next if $seen{$ref};
499                         $seen{$ref} = 1;
500                         push @refs, linkify_ref_nosrch($ref);
501                 }
502
503                 if (@refs) {
504                         $rv .= 'References: '. join(' ', @refs) . "\n";
505                 }
506         }
507         $rv;
508 }
509
510 sub html_footer {
511         my ($mime, $standalone, $full_pfx, $ctx) = @_;
512         my %cc; # everyone else
513         my $to; # this is the From address
514
515         foreach my $h (qw(From To Cc)) {
516                 my $v = $mime->header($h);
517                 defined($v) && ($v ne '') or next;
518                 my @addrs = Email::Address->parse($v);
519                 foreach my $recip (@addrs) {
520                         my $address = $recip->address;
521                         my $dst = lc($address);
522                         $cc{$dst} ||= $address;
523                         $to ||= $dst;
524                 }
525         }
526         Email::Address->purge_cache if $standalone;
527
528         my $subj = $mime->header('Subject') || '';
529         $subj = "Re: $subj" unless $subj =~ /\bRe:/i;
530         my $mid = $mime->header('Message-ID');
531         my $irt = uri_escape_utf8($mid);
532         delete $cc{$to};
533         $to = uri_escape_utf8($to);
534         $subj = uri_escape_utf8($subj);
535
536         my $cc = uri_escape_utf8(join(',', sort values %cc));
537         my $href = "mailto:$to?In-Reply-To=$irt&Cc=${cc}&Subject=$subj";
538
539         my $srch = $ctx->{srch} if $ctx;
540         my $upfx = $full_pfx ? '../' : '../../';
541         my $idx = $standalone ? " <a\nhref=\"$upfx\">index</a>" : '';
542         if ($idx && $srch) {
543                 my ($next, $p) = thread_inline(\$idx, $ctx, $mime, $full_pfx);
544                 if (defined $p) {
545                         $p = PublicInbox::Hval->new_oneline($p);
546                         $p = $p->as_href;
547                         $irt = "<a\nhref=\"$upfx$p/\">parent</a> ";
548                 } else {
549                         $irt = ' ' x length('parent ');
550                 }
551                 if ($next) {
552                         $irt .= "<a\nhref=\"$upfx$next/\">next</a> ";
553                 } else {
554                         $irt .= '     ';
555                 }
556         } else {
557                 $irt = '';
558         }
559
560         "$irt<a\nhref=\"" . ascii_html($href) . '">reply</a>' . $idx;
561 }
562
563 sub linkify_ref_nosrch {
564         my $v = PublicInbox::Hval->new_msgid($_[0], 1);
565         my $html = $v->as_html;
566         my $href = $v->as_href;
567         "&lt;<a\nhref=\"../$href/\">$html</a>&gt;";
568 }
569
570 sub anchor_for {
571         my ($msgid) = @_;
572         my $id = $msgid;
573         if ($id !~ /\A[a-f0-9]{40}\z/) {
574                 $id = mid_compress(mid_clean($id), 1);
575         }
576         'm' . $id;
577 }
578
579 sub thread_html_head {
580         my ($cb, $mime) = @_;
581         $$cb = $$cb->([200, ['Content-Type'=> 'text/html; charset=UTF-8']]);
582
583         my $s = PublicInbox::Hval->new_oneline($mime->header('Subject'));
584         $s = $s->as_html;
585         $$cb->write("<html><head><title>$s</title></head><body>");
586 }
587
588 sub pre_anchor_entry {
589         my ($seen, $mime) = @_;
590         my $id = anchor_for($mime->header('Message-ID'));
591         $seen->{$id} = "#$id"; # save the anchor for children, later
592 }
593
594 sub __thread_entry {
595         my ($cb, $git, $state, $mime, $level) = @_;
596
597         # lazy load the full message from mini_mime:
598         $mime = eval {
599                 my $path = mid2path(mid_clean($mime->header('Message-ID')));
600                 Email::MIME->new($git->cat_file('HEAD:'.$path));
601         } or return;
602
603         if ($state->{anchor_idx} == 0) {
604                 thread_html_head($cb, $mime, $state);
605         }
606
607         if (my $ghost = delete $state->{ghost}) {
608                 # n.b. ghost messages may only be parents, not children
609                 foreach my $g (@$ghost) {
610                         my $mid = PublicInbox::Hval->new_msgid($g->[0]);
611                         my $pfx = INDENT x $g->[1];
612                         my $href = $mid->as_href;
613                         my $html = $mid->as_html;
614                         $$cb->write("<table><tr><td>$pfx</td><td>" .
615                                         PRE_WRAP .
616                                         '[parent not found: &lt;' .
617                                         qq{<a\nhref="../../$href/">}.
618                                         "$html</a>&gt;]</pre></td></table>");
619                 }
620         }
621         index_entry($$cb, $mime, $level, $state);
622         1;
623 }
624
625 sub __ghost_entry {
626         my ($state, $node, $level) = @_;
627         my $ghost = $state->{ghost} ||= [];
628         push @$ghost, [ $node->messageid, $level ];
629 }
630
631 sub thread_entry {
632         my ($cb, $git, $state, $node, $level) = @_;
633         return unless $node;
634         if (my $mime = $node->message) {
635                 unless (__thread_entry($cb, $git, $state, $mime, $level)) {
636                         __ghost_entry($state, $node, $level);
637                 }
638         } else {
639                 __ghost_entry($state, $node, $level);
640         }
641
642         thread_entry($cb, $git, $state, $node->child, $level + 1);
643         thread_entry($cb, $git, $state, $node->next, $level);
644 }
645
646 sub load_results {
647         my ($res) = @_;
648
649         [ map { $_->mini_mime } @{delete $res->{msgs}} ];
650 }
651
652 sub msg_timestamp {
653         my ($mime) = @_;
654         my $ts = eval { str2time($mime->header('Date')) };
655         defined($ts) ? $ts : 0;
656 }
657
658 sub thread_results {
659         my ($msgs, $nosubject) = @_;
660         require PublicInbox::Thread;
661         my $th = PublicInbox::Thread->new(@$msgs);
662         no warnings 'once';
663         $Mail::Thread::nosubject = $nosubject;
664         $th->thread;
665         $th->order(*PublicInbox::Thread::sort_ts);
666         $th
667 }
668
669 sub missing_thread {
670         my ($cb, $ctx) = @_;
671         require PublicInbox::ExtMsg;
672
673         $cb->(PublicInbox::ExtMsg::ext_msg($ctx))
674 }
675
676 sub _msg_date {
677         my ($mime) = @_;
678         my $ts = $mime->header('X-PI-TS') || msg_timestamp($mime);
679         POSIX::strftime('%Y-%m-%d %H:%M', gmtime($ts));
680 }
681
682 sub _inline_header {
683         my ($dst, $state, $upfx, $mime, $level) = @_;
684         my $pfx = INDENT x $level;
685
686         my $cur = $state->{cur};
687         my $mid = mid_clean($mime->header('Message-ID'));
688         my $f = $mime->header('X-PI-From');
689         my $d = _msg_date($mime);
690         $f = PublicInbox::Hval->new($f);
691         $d = PublicInbox::Hval->new($d);
692         $f = $f->as_html;
693         $d = $d->as_html . ' UTC';
694         if ($cur) {
695                 if ($cur eq $mid) {
696                         delete $state->{cur};
697                         $$dst .= "$pfx` <b><a\nid=\"r\"\nhref=\"#t\">".
698                                  "[this message]</a></b> by $f @ $d\n";
699
700                         return;
701                 }
702         } else {
703                 $state->{next_msg} ||= $mid;
704         }
705
706         # Subject is never undef, this mail was loaded from
707         # our Xapian which would've resulted in '' if it were
708         # really missing (and Filter rejects empty subjects)
709         my $s = $mime->header('Subject');
710         my $h = $state->{srch}->subject_path($s);
711         if ($state->{seen}->{$h}) {
712                 $s = undef;
713         } else {
714                 $state->{seen}->{$h} = 1;
715                 $s = PublicInbox::Hval->new($s);
716                 $s = $s->as_html;
717         }
718         my $m = PublicInbox::Hval->new_msgid($mid);
719         $m = $upfx . '../' . $m->as_href . '/';
720         if (defined $s) {
721                 $$dst .= "$pfx` <a\nhref=\"$m\">$s</a>\n" .
722                          "$pfx  $f @ $d\n";
723         } else {
724                 $$dst .= "$pfx` <a\nhref=\"$m\">$f @ $d</a>\n";
725         }
726 }
727
728 sub inline_dump {
729         my ($dst, $state, $upfx, $node, $level) = @_;
730         return unless $node;
731         if (my $mime = $node->message) {
732                 my $mid = mid_clean($mime->header('Message-ID'));
733                 if ($mid eq $state->{parent_cmp}) {
734                         $state->{parent} = $mid;
735                 }
736                 _inline_header($dst, $state, $upfx, $mime, $level);
737         } else {
738                 my $pfx = INDENT x $level;
739                 my $v = PublicInbox::Hval->new_msgid($node->messageid, 1);
740                 my $html = $v->as_html;
741                 my $href = $v->as_href;
742                 $$dst .= $pfx . '` [parent not found: &lt;' .
743                                 qq{<a\nhref="$upfx../$href/">}.
744                                 "$html</a>&gt;]\n";
745         }
746         inline_dump($dst, $state, $upfx, $node->child, $level+1);
747         inline_dump($dst, $state, $upfx, $node->next, $level);
748 }
749
750 sub rsort_ts {
751         sort {
752                 (eval { $b->topmost->message->header('X-PI-TS') } || 0) <=>
753                 (eval { $a->topmost->message->header('X-PI-TS') } || 0)
754         } @_;
755 }
756
757 # accumulate recent topics if search is supported
758 # returns 1 if done, undef if not
759 sub add_topic {
760         my ($state, $node, $level) = @_;
761         return unless $node;
762
763         if (my $x = $node->message) {
764                 $x = $x->header_obj;
765                 my ($topic, $subj);
766
767                 $subj = $x->header('Subject');
768                 $subj = $state->{srch}->subject_normalized($subj);
769                 $topic = $subj;
770
771                 # kill "[PATCH v2]" etc. for summarization
772                 $topic =~ s/\A\s*\[[^\]]+\]\s*//g;
773                 $topic = substr($topic, 0, 30);
774
775                 if (++$state->{subjs}->{$topic} == 1) {
776                         push @{$state->{order}}, [ $level, $subj, $topic ];
777                 }
778
779                 my $mid = mid_clean($x->header('Message-ID'));
780
781                 my $u = $x->header('X-PI-From');
782                 my $ts = $x->header('X-PI-TS');
783                 $state->{latest}->{$topic} = [ $mid, $u, $ts ];
784         } # else { } # ghost ignored...
785
786         add_topic($state, $node->child, $level + 1);
787         add_topic($state, $node->next, $level);
788 }
789
790 sub dump_topics {
791         my ($state) = @_;
792         my $order = $state->{order};
793         my $subjs = $state->{subjs};
794         my $latest = $state->{latest};
795         return "\n[No recent topics]</pre>" unless (scalar @$order);
796         my $dst = '';
797         my $pfx;
798         my $prev = 0;
799         my $prev_attr = '';
800         while (defined(my $info = shift @$order)) {
801                 my ($level, $subj, $topic) = @$info;
802                 my $n = delete $subjs->{$topic};
803                 my ($mid, $u, $ts) = @{delete $latest->{$topic}};
804                 $mid = PublicInbox::Hval->new($mid)->as_href;
805                 $subj = PublicInbox::Hval->new($subj)->as_html;
806                 $u = PublicInbox::Hval->new($u)->as_html;
807                 $pfx = INDENT x $level;
808                 my $nl = $level == $prev ? "\n" : '';
809                 my $dot = $level == 0 ? '' : '`';
810                 $dst .= "$nl$pfx$dot<a\nhref=\"$mid/t/#u\"><b>$subj</b></a>\n";
811
812                 my $attr;
813                 $ts = POSIX::strftime('%Y-%m-%d %H:%M', gmtime($ts));
814                 if ($n == 1) {
815                         $attr = "created by $u @ $ts UTC";
816                         $n = "\n";
817                 } else {
818                         # $n isn't the total number of posts on the topic,
819                         # just the number of posts in the current results
820                         # window, so leave it unlabeled
821                         $attr = "updated by $u @ $ts UTC";
822                         $n = " ($n)\n";
823                 }
824                 if ($level == 0 || $attr ne $prev_attr) {
825                         $dst .= "$pfx - ". $attr . $n;
826                         $prev_attr = $attr;
827                 }
828         }
829         $dst .= '</pre>';
830 }
831
832 sub emit_index_topics {
833         my ($state, $fh) = @_;
834         my $off = $state->{ctx}->{cgi}->param('o');
835         $off = 0 unless defined $off;
836         $state->{order} = [];
837         $state->{subjs} = {};
838         $state->{latest} = {};
839         my $max = 25;
840         my %opts = ( offset => int $off, limit => $max * 4 );
841         while (scalar @{$state->{order}} < $max) {
842                 my $res = $state->{srch}->query('', \%opts);
843                 my $nr = scalar @{$res->{msgs}} or last;
844
845                 for (rsort_ts(thread_results(load_results($res), 1)->rootset)) {
846                         add_topic($state, $_, 0);
847                 }
848                 $opts{offset} += $nr;
849         }
850
851         $fh->write(dump_topics($state));
852         $opts{offset};
853 }
854
855 1;