]> rtime.felk.cvut.cz Git - notmuch.git/blob - notmuch-search.c
cli: Refactor option passing in the search command
[notmuch.git] / notmuch-search.c
1 /* notmuch - Not much of an email program, (just index and search)
2  *
3  * Copyright © 2009 Carl Worth
4  *
5  * This program is free software: you can redistribute it and/or modify
6  * it under the terms of the GNU General Public License as published by
7  * the Free Software Foundation, either version 3 of the License, or
8  * (at your option) any later version.
9  *
10  * This program is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13  * GNU General Public License for more details.
14  *
15  * You should have received a copy of the GNU General Public License
16  * along with this program.  If not, see http://www.gnu.org/licenses/ .
17  *
18  * Author: Carl Worth <cworth@cworth.org>
19  */
20
21 #include "notmuch-client.h"
22 #include "sprinter.h"
23 #include "string-util.h"
24
25 typedef enum {
26     OUTPUT_SUMMARY,
27     OUTPUT_THREADS,
28     OUTPUT_MESSAGES,
29     OUTPUT_FILES,
30     OUTPUT_TAGS
31 } output_t;
32
33 typedef struct {
34     sprinter_t *format;
35     notmuch_query_t *query;
36     notmuch_sort_t sort;
37     output_t output;
38     int offset;
39     int limit;
40     int dupe;
41 } search_options_t;
42
43 /* Return two stable query strings that identify exactly the matched
44  * and unmatched messages currently in thread.  If there are no
45  * matched or unmatched messages, the returned buffers will be
46  * NULL. */
47 static int
48 get_thread_query (notmuch_thread_t *thread,
49                   char **matched_out, char **unmatched_out)
50 {
51     notmuch_messages_t *messages;
52     char *escaped = NULL;
53     size_t escaped_len = 0;
54
55     *matched_out = *unmatched_out = NULL;
56
57     for (messages = notmuch_thread_get_messages (thread);
58          notmuch_messages_valid (messages);
59          notmuch_messages_move_to_next (messages))
60     {
61         notmuch_message_t *message = notmuch_messages_get (messages);
62         const char *mid = notmuch_message_get_message_id (message);
63         /* Determine which query buffer to extend */
64         char **buf = notmuch_message_get_flag (
65             message, NOTMUCH_MESSAGE_FLAG_MATCH) ? matched_out : unmatched_out;
66         /* Add this message's id: query.  Since "id" is an exclusive
67          * prefix, it is implicitly 'or'd together, so we only need to
68          * join queries with a space. */
69         if (make_boolean_term (thread, "id", mid, &escaped, &escaped_len) < 0)
70             return -1;
71         if (*buf)
72             *buf = talloc_asprintf_append_buffer (*buf, " %s", escaped);
73         else
74             *buf = talloc_strdup (thread, escaped);
75         if (!*buf)
76             return -1;
77     }
78     talloc_free (escaped);
79     return 0;
80 }
81
82 static int
83 do_search_threads (search_options_t *o)
84 {
85     notmuch_thread_t *thread;
86     notmuch_threads_t *threads;
87     notmuch_tags_t *tags;
88     sprinter_t *format = o->format;
89     time_t date;
90     int i;
91
92     if (o->offset < 0) {
93         o->offset += notmuch_query_count_threads (o->query);
94         if (o->offset < 0)
95             o->offset = 0;
96     }
97
98     threads = notmuch_query_search_threads (o->query);
99     if (threads == NULL)
100         return 1;
101
102     format->begin_list (format);
103
104     for (i = 0;
105          notmuch_threads_valid (threads) && (o->limit < 0 || i < o->offset + o->limit);
106          notmuch_threads_move_to_next (threads), i++)
107     {
108         thread = notmuch_threads_get (threads);
109
110         if (i < o->offset) {
111             notmuch_thread_destroy (thread);
112             continue;
113         }
114
115         if (o->output == OUTPUT_THREADS) {
116             format->set_prefix (format, "thread");
117             format->string (format,
118                                notmuch_thread_get_thread_id (thread));
119             format->separator (format);
120         } else { /* output == OUTPUT_SUMMARY */
121             void *ctx_quote = talloc_new (thread);
122             const char *authors = notmuch_thread_get_authors (thread);
123             const char *subject = notmuch_thread_get_subject (thread);
124             const char *thread_id = notmuch_thread_get_thread_id (thread);
125             int matched = notmuch_thread_get_matched_messages (thread);
126             int total = notmuch_thread_get_total_messages (thread);
127             const char *relative_date = NULL;
128             notmuch_bool_t first_tag = TRUE;
129
130             format->begin_map (format);
131
132             if (o->sort == NOTMUCH_SORT_OLDEST_FIRST)
133                 date = notmuch_thread_get_oldest_date (thread);
134             else
135                 date = notmuch_thread_get_newest_date (thread);
136
137             relative_date = notmuch_time_relative_date (ctx_quote, date);
138
139             if (format->is_text_printer) {
140                 /* Special case for the text formatter */
141                 printf ("thread:%s %12s [%d/%d] %s; %s (",
142                         thread_id,
143                         relative_date,
144                         matched,
145                         total,
146                         sanitize_string (ctx_quote, authors),
147                         sanitize_string (ctx_quote, subject));
148             } else { /* Structured Output */
149                 format->map_key (format, "thread");
150                 format->string (format, thread_id);
151                 format->map_key (format, "timestamp");
152                 format->integer (format, date);
153                 format->map_key (format, "date_relative");
154                 format->string (format, relative_date);
155                 format->map_key (format, "matched");
156                 format->integer (format, matched);
157                 format->map_key (format, "total");
158                 format->integer (format, total);
159                 format->map_key (format, "authors");
160                 format->string (format, authors);
161                 format->map_key (format, "subject");
162                 format->string (format, subject);
163                 if (notmuch_format_version >= 2) {
164                     char *matched_query, *unmatched_query;
165                     if (get_thread_query (thread, &matched_query,
166                                           &unmatched_query) < 0) {
167                         fprintf (stderr, "Out of memory\n");
168                         return 1;
169                     }
170                     format->map_key (format, "query");
171                     format->begin_list (format);
172                     if (matched_query)
173                         format->string (format, matched_query);
174                     else
175                         format->null (format);
176                     if (unmatched_query)
177                         format->string (format, unmatched_query);
178                     else
179                         format->null (format);
180                     format->end (format);
181                 }
182             }
183
184             talloc_free (ctx_quote);
185
186             format->map_key (format, "tags");
187             format->begin_list (format);
188
189             for (tags = notmuch_thread_get_tags (thread);
190                  notmuch_tags_valid (tags);
191                  notmuch_tags_move_to_next (tags))
192             {
193                 const char *tag = notmuch_tags_get (tags);
194
195                 if (format->is_text_printer) {
196                   /* Special case for the text formatter */
197                     if (first_tag)
198                         first_tag = FALSE;
199                     else
200                         fputc (' ', stdout);
201                     fputs (tag, stdout);
202                 } else { /* Structured Output */
203                     format->string (format, tag);
204                 }
205             }
206
207             if (format->is_text_printer)
208                 printf (")");
209
210             format->end (format);
211             format->end (format);
212             format->separator (format);
213         }
214
215         notmuch_thread_destroy (thread);
216     }
217
218     format->end (format);
219
220     return 0;
221 }
222
223 static int
224 do_search_messages (search_options_t *o)
225 {
226     notmuch_message_t *message;
227     notmuch_messages_t *messages;
228     notmuch_filenames_t *filenames;
229     sprinter_t *format = o->format;
230     int i;
231
232     if (o->offset < 0) {
233         o->offset += notmuch_query_count_messages (o->query);
234         if (o->offset < 0)
235             o->offset = 0;
236     }
237
238     messages = notmuch_query_search_messages (o->query);
239     if (messages == NULL)
240         return 1;
241
242     format->begin_list (format);
243
244     for (i = 0;
245          notmuch_messages_valid (messages) && (o->limit < 0 || i < o->offset + o->limit);
246          notmuch_messages_move_to_next (messages), i++)
247     {
248         if (i < o->offset)
249             continue;
250
251         message = notmuch_messages_get (messages);
252
253         if (o->output == OUTPUT_FILES) {
254             int j;
255             filenames = notmuch_message_get_filenames (message);
256
257             for (j = 1;
258                  notmuch_filenames_valid (filenames);
259                  notmuch_filenames_move_to_next (filenames), j++)
260             {
261                 if (o->dupe < 0 || o->dupe == j) {
262                     format->string (format, notmuch_filenames_get (filenames));
263                     format->separator (format);
264                 }
265             }
266             
267             notmuch_filenames_destroy( filenames );
268
269         } else { /* output == OUTPUT_MESSAGES */
270             format->set_prefix (format, "id");
271             format->string (format,
272                             notmuch_message_get_message_id (message));
273             format->separator (format);
274         }
275
276         notmuch_message_destroy (message);
277     }
278
279     notmuch_messages_destroy (messages);
280
281     format->end (format);
282
283     return 0;
284 }
285
286 static int
287 do_search_tags (notmuch_database_t *notmuch,
288                 sprinter_t *format,
289                 notmuch_query_t *query)
290 {
291     notmuch_messages_t *messages = NULL;
292     notmuch_tags_t *tags;
293     const char *tag;
294
295     /* should the following only special case if no excluded terms
296      * specified? */
297
298     /* Special-case query of "*" for better performance. */
299     if (strcmp (notmuch_query_get_query_string (query), "*") == 0) {
300         tags = notmuch_database_get_all_tags (notmuch);
301     } else {
302         messages = notmuch_query_search_messages (query);
303         if (messages == NULL)
304             return 1;
305
306         tags = notmuch_messages_collect_tags (messages);
307     }
308     if (tags == NULL)
309         return 1;
310
311     format->begin_list (format);
312
313     for (;
314          notmuch_tags_valid (tags);
315          notmuch_tags_move_to_next (tags))
316     {
317         tag = notmuch_tags_get (tags);
318
319         format->string (format, tag);
320         format->separator (format);
321
322     }
323
324     notmuch_tags_destroy (tags);
325
326     if (messages)
327         notmuch_messages_destroy (messages);
328
329     format->end (format);
330
331     return 0;
332 }
333
334 int
335 notmuch_search_command (notmuch_config_t *config, int argc, char *argv[])
336 {
337     notmuch_database_t *notmuch;
338     search_options_t o = {
339         .sort = NOTMUCH_SORT_NEWEST_FIRST,
340         .output = OUTPUT_SUMMARY,
341         .offset = 0,
342         .limit = -1, /* unlimited */
343         .dupe = -1,
344     };
345     char *query_str;
346     int opt_index, ret;
347     notmuch_exclude_t exclude = NOTMUCH_EXCLUDE_TRUE;
348     unsigned int i;
349
350     enum {
351         NOTMUCH_FORMAT_JSON,
352         NOTMUCH_FORMAT_TEXT,
353         NOTMUCH_FORMAT_TEXT0,
354         NOTMUCH_FORMAT_SEXP
355     } format_sel = NOTMUCH_FORMAT_TEXT;
356
357     notmuch_opt_desc_t options[] = {
358         { NOTMUCH_OPT_KEYWORD, &o.sort, "sort", 's',
359           (notmuch_keyword_t []){ { "oldest-first", NOTMUCH_SORT_OLDEST_FIRST },
360                                   { "newest-first", NOTMUCH_SORT_NEWEST_FIRST },
361                                   { 0, 0 } } },
362         { NOTMUCH_OPT_KEYWORD, &format_sel, "format", 'f',
363           (notmuch_keyword_t []){ { "json", NOTMUCH_FORMAT_JSON },
364                                   { "sexp", NOTMUCH_FORMAT_SEXP },
365                                   { "text", NOTMUCH_FORMAT_TEXT },
366                                   { "text0", NOTMUCH_FORMAT_TEXT0 },
367                                   { 0, 0 } } },
368         { NOTMUCH_OPT_INT, &notmuch_format_version, "format-version", 0, 0 },
369         { NOTMUCH_OPT_KEYWORD, &o.output, "output", 'o',
370           (notmuch_keyword_t []){ { "summary", OUTPUT_SUMMARY },
371                                   { "threads", OUTPUT_THREADS },
372                                   { "messages", OUTPUT_MESSAGES },
373                                   { "files", OUTPUT_FILES },
374                                   { "tags", OUTPUT_TAGS },
375                                   { 0, 0 } } },
376         { NOTMUCH_OPT_KEYWORD, &exclude, "exclude", 'x',
377           (notmuch_keyword_t []){ { "true", NOTMUCH_EXCLUDE_TRUE },
378                                   { "false", NOTMUCH_EXCLUDE_FALSE },
379                                   { "flag", NOTMUCH_EXCLUDE_FLAG },
380                                   { "all", NOTMUCH_EXCLUDE_ALL },
381                                   { 0, 0 } } },
382         { NOTMUCH_OPT_INT, &o.offset, "offset", 'O', 0 },
383         { NOTMUCH_OPT_INT, &o.limit, "limit", 'L', 0  },
384         { NOTMUCH_OPT_INT, &o.dupe, "duplicate", 'D', 0  },
385         { 0, 0, 0, 0, 0 }
386     };
387
388     opt_index = parse_arguments (argc, argv, options, 1);
389     if (opt_index < 0)
390         return EXIT_FAILURE;
391
392     switch (format_sel) {
393     case NOTMUCH_FORMAT_TEXT:
394         o.format = sprinter_text_create (config, stdout);
395         break;
396     case NOTMUCH_FORMAT_TEXT0:
397         if (o.output == OUTPUT_SUMMARY) {
398             fprintf (stderr, "Error: --format=text0 is not compatible with --output=summary.\n");
399             return EXIT_FAILURE;
400         }
401         o.format = sprinter_text0_create (config, stdout);
402         break;
403     case NOTMUCH_FORMAT_JSON:
404         o.format = sprinter_json_create (config, stdout);
405         break;
406     case NOTMUCH_FORMAT_SEXP:
407         o.format = sprinter_sexp_create (config, stdout);
408         break;
409     default:
410         /* this should never happen */
411         INTERNAL_ERROR("no output format selected");
412     }
413
414     notmuch_exit_if_unsupported_format ();
415
416     if (notmuch_database_open (notmuch_config_get_database_path (config),
417                                NOTMUCH_DATABASE_MODE_READ_ONLY, &notmuch))
418         return EXIT_FAILURE;
419
420     query_str = query_string_from_args (notmuch, argc-opt_index, argv+opt_index);
421     if (query_str == NULL) {
422         fprintf (stderr, "Out of memory.\n");
423         return EXIT_FAILURE;
424     }
425     if (*query_str == '\0') {
426         fprintf (stderr, "Error: notmuch search requires at least one search term.\n");
427         return EXIT_FAILURE;
428     }
429
430     o.query = notmuch_query_create (notmuch, query_str);
431     if (o.query == NULL) {
432         fprintf (stderr, "Out of memory\n");
433         return EXIT_FAILURE;
434     }
435
436     notmuch_query_set_sort (o.query, o.sort);
437
438     if (exclude == NOTMUCH_EXCLUDE_FLAG && o.output != OUTPUT_SUMMARY) {
439         /* If we are not doing summary output there is nowhere to
440          * print the excluded flag so fall back on including the
441          * excluded messages. */
442         fprintf (stderr, "Warning: this output format cannot flag excluded messages.\n");
443         exclude = NOTMUCH_EXCLUDE_FALSE;
444     }
445
446     if (exclude != NOTMUCH_EXCLUDE_FALSE) {
447         const char **search_exclude_tags;
448         size_t search_exclude_tags_length;
449
450         search_exclude_tags = notmuch_config_get_search_exclude_tags
451             (config, &search_exclude_tags_length);
452         for (i = 0; i < search_exclude_tags_length; i++)
453             notmuch_query_add_tag_exclude (o.query, search_exclude_tags[i]);
454         notmuch_query_set_omit_excluded (o.query, exclude);
455     }
456
457     switch (o.output) {
458     default:
459     case OUTPUT_SUMMARY:
460     case OUTPUT_THREADS:
461         ret = do_search_threads (&o);
462         break;
463     case OUTPUT_MESSAGES:
464     case OUTPUT_FILES:
465         ret = do_search_messages (&o);
466         break;
467     case OUTPUT_TAGS:
468         ret = do_search_tags (notmuch, o.format, o.query);
469         break;
470     }
471
472     notmuch_query_destroy (o.query);
473     notmuch_database_destroy (notmuch);
474
475     talloc_free (o.format);
476
477     return ret ? EXIT_FAILURE : EXIT_SUCCESS;
478 }