lib/PublicInbox/SearchMsg.pm

   1 # Copyright (C) 2015 all contributors <meta@public-inbox.org>
   2 # License: GPLv3 or later (https://www.gnu.org/licenses/agpl-3.0.txt)
   3 # based on notmuch, but with no concept of folders, files or flags
   4 package PublicInbox::SearchMsg;
   5 use strict;
   6 use warnings;
   7 use Search::Xapian;
   8 use Email::Address qw//;
   9 use Email::Simple qw//;
  10 use POSIX qw//;
  11 use Date::Parse qw/str2time/;
  12 use PublicInbox::MID qw/mid_clean/;
  13 use Encode qw/find_encoding/;
  14 my $enc_utf8 = find_encoding('UTF-8');
  15 our $PFX2TERM_RE = undef;
  16 use constant EPOCH_822 => 'Thu, 01 Jan 1970 00:00:00 +0000';
  17
  18 sub new {
  19         my ($class, $mime) = @_;
  20         my $doc = Search::Xapian::Document->new;
  21         $doc->add_term(PublicInbox::Search::xpfx('type') . 'mail');
  22
  23         bless { type => 'mail', doc => $doc, mime => $mime }, $class;
  24 }
  25
  26 sub wrap {
  27         my ($class, $doc, $mid) = @_;
  28         bless { doc => $doc, mime => undef, mid => $mid }, $class;
  29 }
  30
  31 sub load_doc {
  32         my ($class, $doc) = @_;
  33         my $data = $doc->get_data;
  34         my $ts = eval {
  35                 no strict 'subs';
  36                 $doc->get_value(PublicInbox::Search::TS);
  37         };
  38         $ts = Search::Xapian::sortable_unserialise($ts);
  39         $data = $enc_utf8->decode($data);
  40         my ($subj, $from, $refs) = split(/\n/, $data);
  41         bless {
  42                 doc => $doc,
  43                 subject => $subj,
  44                 ts => $ts,
  45                 from_name => $from,
  46                 references_sorted => $refs,
  47         }, $class;
  48 }
  49
  50 sub subject {
  51         my ($self) = @_;
  52         my $subj = $self->{subject};
  53         return $subj if defined $subj;
  54         $subj = $self->{mime}->header('Subject');
  55         $subj = '' unless defined $subj;
  56         $subj =~ tr/\n/ /;
  57         $self->{subject} = $subj;
  58 }
  59
  60 sub from {
  61         my ($self) = @_;
  62         my $from = $self->mime->header('From') || '';
  63         my @from;
  64
  65         if ($from) {
  66                 $from =~ tr/\n/ /;
  67                 @from = Email::Address->parse($from);
  68                 $self->{from} = $from[0];
  69                 $from = $from[0]->name;
  70         }
  71         $self->{from_name} = $from;
  72         $self->{from};
  73 }
  74
  75 sub from_name {
  76         my ($self) = @_;
  77         my $from_name = $self->{from_name};
  78         return $from_name if defined $from_name;
  79         $self->from;
  80         $self->{from_name};
  81 }
  82
  83 sub ts {
  84         my ($self) = @_;
  85         $self->{ts} ||= eval { str2time($self->mime->header('Date')) } || 0;
  86 }
  87
  88 sub to_doc_data {
  89         my ($self) = @_;
  90         PublicInbox::Search::subject_summary($self->subject) . "\n" .
  91         $self->from_name . "\n".
  92         $self->references_sorted;
  93 }
  94
  95 sub references_sorted {
  96         my ($self) = @_;
  97         my $x = $self->{references_sorted};
  98         defined $x ? $x : '';
  99 }
 100
 101 sub ensure_metadata {
 102         my ($self) = @_;
 103         my $doc = $self->{doc};
 104         my $end = $doc->termlist_end;
 105
 106         unless (defined $PFX2TERM_RE) {
 107                 my $or = join('|', keys %PublicInbox::Search::PFX2TERM_RMAP);
 108                 $PFX2TERM_RE = qr/\A($or)/;
 109         }
 110
 111         while (my ($pfx, $field) = each %PublicInbox::Search::PFX2TERM_RMAP) {
 112                 # ideally we'd move this out of the loop:
 113                 my $i = $doc->termlist_begin;
 114
 115                 $i->skip_to($pfx);
 116                 if ($i != $end) {
 117                         my $val = $i->get_termname;
 118
 119                         if ($val =~ s/$PFX2TERM_RE//o) {
 120                                 $self->{$field} = $val;
 121                         }
 122                 }
 123         }
 124 }
 125
 126 # for threading only
 127 sub mini_mime {
 128         my ($self) = @_;
 129         $self->ensure_metadata;
 130         my @hs = (
 131                 'Subject' => $self->subject,
 132                 'X-PI-From' => $self->from_name,
 133         );
 134
 135         my @h = (
 136                 # prevent Email::Simple::Creator from running,
 137                 # this header is useless for threading as we use X-PI-TS
 138                 # for sorting and display:
 139                 'Date' => EPOCH_822,
 140                 'Message-ID' => "<$self->{mid}>",
 141                 'X-PI-TS' => $self->ts,
 142         );
 143         if (my $refs = $self->{references_sorted}) {
 144                 $refs =~ s/></> </g;
 145                 push @h, References => $refs;
 146         }
 147         my $mime = Email::MIME->create(header_str => \@hs, header => \@h);
 148         my $h = $mime->header_obj;
 149
 150         # set these headers manually since Encode::encode('MIME-Q', ...)
 151         # will add spaces to long values when using header_str above.
 152
 153         # drop useless headers Email::MIME set for us
 154         $h->header_set('Date');
 155         $h->header_set('MIME-Version');
 156         $mime;
 157 }
 158
 159 sub mid {
 160         my ($self, $mid) = @_;
 161
 162         if (defined $mid) {
 163                 $self->{mid} = $mid;
 164         } elsif (my $rv = $self->{mid}) {
 165                 $rv;
 166         } else {
 167                 $self->ensure_metadata; # needed for ghosts
 168                 $self->{mid} ||= $self->_extract_mid;
 169         }
 170 }
 171
 172 sub _extract_mid {
 173         my ($self) = @_;
 174
 175         my $mid = $self->mime->header('Message-ID');
 176         defined $mid ? mid_clean($mid) : $mid;
 177 }
 178
 179 sub mime {
 180         my ($self, $mime) = @_;
 181         if (defined $mime) {
 182                 $self->{mime} = $mime;
 183         } else {
 184                 # TODO load from git
 185                 $self->{mime};
 186         }
 187 }
 188
 189 sub doc_id {
 190         my ($self, $doc_id) = @_;
 191         if (defined $doc_id) {
 192                 $self->{doc_id} = $doc_id;
 193         } else {
 194                 # TODO load from xapian
 195                 $self->{doc_id};
 196         }
 197 }
 198
 199 sub thread_id {
 200         my ($self) = @_;
 201         my $tid = $self->{thread};
 202         return $tid if defined $tid;
 203         $self->ensure_metadata;
 204         $self->{thread};
 205 }
 206
 207 sub path {
 208         my ($self) = @_;
 209         my $path = $self->{path};
 210         return $path if defined $path;
 211         $self->ensure_metadata;
 212         $self->{path};
 213 }
 214
 215 1;