]> Sergey Matveev's repositories - public-inbox.git/blob - lib/PublicInbox/SearchMsg.pm
search: preserve References: order in document data
[public-inbox.git] / 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 mid_compressed/;
13 use Encode qw/find_encoding/;
14 my $enc_utf8 = find_encoding('UTF-8');
15 our $PFX2TERM_RE = undef;
16
17 sub new {
18         my ($class, $mime) = @_;
19         my $doc = Search::Xapian::Document->new;
20         $doc->add_term(PublicInbox::Search::xpfx('type') . 'mail');
21
22         bless { type => 'mail', doc => $doc, mime => $mime }, $class;
23 }
24
25 sub wrap {
26         my ($class, $doc, $mid) = @_;
27         bless { doc => $doc, mime => undef, mid => $mid }, $class;
28 }
29
30 sub load_doc {
31         my ($class, $doc) = @_;
32         my $data = $doc->get_data;
33         $data = $enc_utf8->decode($data);
34         my ($mid, $subj, $from, $date, $refs) = split(/\n/, $data);
35         bless {
36                 doc => $doc,
37                 mid => $mid,
38                 subject => $subj,
39                 date => $date,
40                 from_name => $from,
41                 references_sorted => $refs,
42         }, $class;
43 }
44
45 sub subject {
46         my ($self) = @_;
47         my $subj = $self->{subject};
48         return $subj if defined $subj;
49         $subj = $self->{mime}->header('Subject');
50         $subj = '' unless defined $subj;
51         $subj =~ tr/\n/ /;
52         $self->{subject} = $subj;
53 }
54
55 sub from {
56         my ($self) = @_;
57         my $from = $self->mime->header('From') || '';
58         my @from;
59
60         if ($from) {
61                 $from =~ tr/\n/ /;
62                 @from = Email::Address->parse($from);
63                 $self->{from} = $from[0];
64                 $from = $from[0]->name;
65         }
66         $self->{from_name} = $from;
67         $self->{from};
68 }
69
70 sub from_name {
71         my ($self) = @_;
72         my $from_name = $self->{from_name};
73         return $from_name if defined $from_name;
74         $self->from;
75         $self->{from_name};
76 }
77
78 sub ts {
79         my ($self) = @_;
80         my $ts = $self->{ts};
81         return $ts if $ts;
82         $self->{ts} = eval {
83                 str2time($self->date || $self->mime->header('Date'))
84         } || 0;
85 }
86
87 sub date {
88         my ($self) = @_;
89         my $date = $self->{date};
90         return $date if $date;
91         my $ts = eval { str2time($self->mime->header('Date')) };
92         $self->{date} = POSIX::strftime('%Y-%m-%d %H:%M', gmtime($ts));
93 }
94
95 sub to_doc_data {
96         my ($self) = @_;
97
98         $self->mid . "\n" .
99         $self->subject . "\n" .
100         $self->from_name . "\n".
101         $self->date . "\n" .
102         $self->references_sorted;
103 }
104
105 sub references_sorted {
106         my ($self) = @_;
107         my $x = $self->{references_sorted};
108         defined $x ? $x : '';
109 }
110
111 sub ensure_metadata {
112         my ($self) = @_;
113         my $doc = $self->{doc};
114         my $i = $doc->termlist_begin;
115         my $end = $doc->termlist_end;
116
117         unless (defined $PFX2TERM_RE) {
118                 my $or = join('|', keys %PublicInbox::Search::PFX2TERM_RMAP);
119                 $PFX2TERM_RE = qr/\A($or)/;
120         }
121
122         for (; $i != $end; $i->inc) {
123                 my $val = $i->get_termname;
124
125                 if ($val =~ s/$PFX2TERM_RE//o) {
126                         my $field = $PublicInbox::Search::PFX2TERM_RMAP{$1};
127                         $self->{$field} = $val;
128                 }
129         }
130 }
131
132 # for threading only
133 sub mini_mime {
134         my ($self) = @_;
135         $self->ensure_metadata;
136         my @h = (
137                 Subject => $self->subject,
138                 'X-PI-From' => $self->from_name,
139                 'X-PI-Date' => $self->date,
140                 'X-PI-TS' => $self->ts,
141                 'Message-ID' => "<$self->{mid}>",
142         );
143
144         my $refs = $self->{references_sorted};
145         my $mime = Email::MIME->create(header_str => \@h);
146         $mime->header_set('References', $refs) if (defined $refs);
147         $mime;
148 }
149
150 sub mid {
151         my ($self, $mid) = @_;
152
153         if (defined $mid) {
154                 $self->{mid} = $mid;
155         } else {
156                 $self->ensure_metadata; # needed for ghosts
157                 $self->{mid} ||= $self->_extract_mid;
158         }
159 }
160
161 sub _extract_mid {
162         my ($self) = @_;
163
164         my $mid = $self->mime->header('Message-ID');
165         $mid ? mid_compressed(mid_clean($mid)) : $mid;
166 }
167
168 sub mime {
169         my ($self, $mime) = @_;
170         if (defined $mime) {
171                 $self->{mime} = $mime;
172         } else {
173                 # TODO load from git
174                 $self->{mime};
175         }
176 }
177
178 sub doc_id {
179         my ($self, $doc_id) = @_;
180         if (defined $doc_id) {
181                 $self->{doc_id} = $doc_id;
182         } else {
183                 # TODO load from xapian
184                 $self->{doc_id};
185         }
186 }
187
188 sub thread_id {
189         my ($self) = @_;
190         my $tid = $self->{thread};
191         return $tid if defined $tid;
192         $self->ensure_metadata;
193         $self->{thread};
194 }
195
196 sub path {
197         my ($self) = @_;
198         my $path = $self->{path};
199         return $path if defined $path;
200         $self->ensure_metadata;
201         $self->{path};
202 }
203
204 1;