static void
format_message_json (const void *ctx, notmuch_message_t *message)
{
notmuch_tags_t *tags;
int first = 1;
void *ctx_quote = talloc_new (ctx);
time_t date;
const char *relative_date;
date = notmuch_message_get_date (message);
relative_date = notmuch_time_relative_date (ctx, date);
printf ("\"id\": %s, \"match\": %s, \"excluded\": %s, \"filename\": %s, \"timestamp\": %ld, \"date_relative\": \"%s\", \"tags\": [",
json_quote_str (ctx_quote, notmuch_message_get_message_id (message)),
notmuch_message_get_flag (message, NOTMUCH_MESSAGE_FLAG_MATCH) ? "true" : "false",
notmuch_message_get_flag (message, NOTMUCH_MESSAGE_FLAG_EXCLUDED) ? "true" : "false",
json_quote_str (ctx_quote, notmuch_message_get_filename (message)),
date, relative_date);
for (tags = notmuch_message_get_tags (message);
notmuch_tags_valid (tags);
notmuch_tags_move_to_next (tags))
{
printf("%s%s", first ? "" : ",",
json_quote_str (ctx_quote, notmuch_tags_get (tags)));
first = 0;
}
printf("], ");
talloc_free (ctx_quote);
}
static void
format_thread_text (const void *ctx,
const char *thread_id,
const time_t date,
const int matched,
const int total,
const char *authors,
const char *subject)
{
printf ("thread:%s %12s [%d/%d] %s; %s",
thread_id,
notmuch_time_relative_date (ctx, date),
matched,
total,
authors,
subject);
}
/* Get a nice, single-line summary of message. */
static const char *
_get_one_line_summary (const void *ctx, notmuch_message_t *message)
{
const char *from;
time_t date;
const char *relative_date;
const char *tags;
from = notmuch_message_get_header (message, "from");
date = notmuch_message_get_date (message);
relative_date = notmuch_time_relative_date (ctx, date);
tags = _get_tags_as_string (ctx, message);
return talloc_asprintf (ctx, "%s (%s) (%s)",
from, relative_date, tags);
}
/* Emit a sequence of key/value pairs for the metadata of message.
* The caller should begin a map before calling this. */
static void
format_message_sprinter (sprinter_t *sp, notmuch_message_t *message)
{
/* Any changes to the JSON or S-Expression format should be
* reflected in the file devel/schemata. */
void *local = talloc_new (NULL);
notmuch_tags_t *tags;
time_t date;
const char *relative_date;
sp->map_key (sp, "id");
sp->string (sp, notmuch_message_get_message_id (message));
sp->map_key (sp, "match");
sp->boolean (sp, notmuch_message_get_flag (message, NOTMUCH_MESSAGE_FLAG_MATCH));
sp->map_key (sp, "excluded");
sp->boolean (sp, notmuch_message_get_flag (message, NOTMUCH_MESSAGE_FLAG_EXCLUDED));
sp->map_key (sp, "filename");
sp->string (sp, notmuch_message_get_filename (message));
sp->map_key (sp, "timestamp");
date = notmuch_message_get_date (message);
sp->integer (sp, date);
sp->map_key (sp, "date_relative");
relative_date = notmuch_time_relative_date (local, date);
sp->string (sp, relative_date);
sp->map_key (sp, "tags");
sp->begin_list (sp);
for (tags = notmuch_message_get_tags (message);
notmuch_tags_valid (tags);
notmuch_tags_move_to_next (tags))
sp->string (sp, notmuch_tags_get (tags));
sp->end (sp);
talloc_free (local);
}
static void
format_thread_text (const void *ctx,
const char *thread_id,
const time_t date,
const int matched,
const int total,
const char *authors,
const char *subject)
{
void *ctx_quote = talloc_new (ctx);
printf ("thread:%s %12s [%d/%d] %s; %s",
thread_id,
notmuch_time_relative_date (ctx, date),
matched,
total,
sanitize_string (ctx_quote, authors),
sanitize_string (ctx_quote, subject));
talloc_free (ctx_quote);
}
static int
do_search_threads (search_context_t *ctx)
{
notmuch_thread_t *thread;
notmuch_threads_t *threads;
notmuch_tags_t *tags;
sprinter_t *format = ctx->format;
time_t date;
int i;
notmuch_status_t status;
if (ctx->offset < 0) {
unsigned count;
notmuch_status_t status;
status = notmuch_query_count_threads_st (ctx->query, &count);
if (print_status_query ("notmuch search", ctx->query, status))
return 1;
ctx->offset += count;
if (ctx->offset < 0)
ctx->offset = 0;
}
status = notmuch_query_search_threads_st (ctx->query, &threads);
if (print_status_query("notmuch search", ctx->query, status))
return 1;
format->begin_list (format);
for (i = 0;
notmuch_threads_valid (threads) && (ctx->limit < 0 || i < ctx->offset + ctx->limit);
notmuch_threads_move_to_next (threads), i++)
{
thread = notmuch_threads_get (threads);
if (i < ctx->offset) {
notmuch_thread_destroy (thread);
continue;
}
if (ctx->output == OUTPUT_THREADS) {
format->set_prefix (format, "thread");
format->string (format,
notmuch_thread_get_thread_id (thread));
format->separator (format);
} else { /* output == OUTPUT_SUMMARY */
void *ctx_quote = talloc_new (thread);
const char *authors = notmuch_thread_get_authors (thread);
const char *subject = notmuch_thread_get_subject (thread);
const char *thread_id = notmuch_thread_get_thread_id (thread);
int matched = notmuch_thread_get_matched_messages (thread);
int total = notmuch_thread_get_total_messages (thread);
const char *relative_date = NULL;
notmuch_bool_t first_tag = TRUE;
format->begin_map (format);
if (ctx->sort == NOTMUCH_SORT_OLDEST_FIRST)
date = notmuch_thread_get_oldest_date (thread);
else
date = notmuch_thread_get_newest_date (thread);
relative_date = notmuch_time_relative_date (ctx_quote, date);
if (format->is_text_printer) {
/* Special case for the text formatter */
printf ("thread:%s %12s [%d/%d] %s; %s (",
thread_id,
relative_date,
matched,
total,
sanitize_string (ctx_quote, authors),
sanitize_string (ctx_quote, subject));
} else { /* Structured Output */
format->map_key (format, "thread");
format->string (format, thread_id);
format->map_key (format, "timestamp");
format->integer (format, date);
format->map_key (format, "date_relative");
format->string (format, relative_date);
format->map_key (format, "matched");
format->integer (format, matched);
format->map_key (format, "total");
format->integer (format, total);
format->map_key (format, "authors");
format->string (format, authors);
format->map_key (format, "subject");
format->string (format, subject);
if (notmuch_format_version >= 2) {
char *matched_query, *unmatched_query;
if (get_thread_query (thread, &matched_query,
&unmatched_query) < 0) {
fprintf (stderr, "Out of memory\n");
return 1;
}
format->map_key (format, "query");
format->begin_list (format);
if (matched_query)
format->string (format, matched_query);
else
format->null (format);
if (unmatched_query)
format->string (format, unmatched_query);
else
format->null (format);
format->end (format);
}
}
talloc_free (ctx_quote);
format->map_key (format, "tags");
format->begin_list (format);
for (tags = notmuch_thread_get_tags (thread);
notmuch_tags_valid (tags);
notmuch_tags_move_to_next (tags))
{
const char *tag = notmuch_tags_get (tags);
if (format->is_text_printer) {
/* Special case for the text formatter */
if (first_tag)
first_tag = FALSE;
else
fputc (' ', stdout);
fputs (tag, stdout);
} else { /* Structured Output */
format->string (format, tag);
}
}
if (format->is_text_printer)
printf (")");
format->end (format);
format->end (format);
format->separator (format);
}
notmuch_thread_destroy (thread);
}
format->end (format);
return 0;
}