debian/notmuch
1
0
Fork 0
mirror of https://git.notmuchmail.org/git/notmuch synced 2024-11-22 10:58:10 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions
notmuch/notmuch-show.c

1231 lines
35 KiB
C
Raw Normal View History

notmuch: Break notmuch.c up into several smaller files. Now that the client sources are alone here in their own directory, (with all the library sources down inside the lib directory), we can break the client up into multiple files without mixing the files up. The hope is that these smaller files will be easier to manage and maintain.
2009-11-10 21:03:05 +01:00
/* notmuch - Not much of an email program, (just index and search)
*
* Copyright © 2009 Carl Worth
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
Use https instead of http where possible Many of the external links found in the notmuch source can be resolved using https instead of http. This changeset addresses as many as i could find, without touching the e-mail corpus or expected outputs found in tests.
2016-06-02 18:26:14 +02:00
* along with this program. If not, see https://www.gnu.org/licenses/ .
notmuch: Break notmuch.c up into several smaller files. Now that the client sources are alone here in their own directory, (with all the library sources down inside the lib directory), we can break the client up into multiple files without mixing the files up. The hope is that these smaller files will be easier to manage and maintain.
2009-11-10 21:03:05 +01:00
*
* Author: Carl Worth <cworth@cworth.org>
*/
#include "notmuch-client.h"
show/reply: Unify the code that extracts text parts Previously, show and reply had separate implementations of decoding and printing text parts. Now both use show's implementation, which was more complete. Show's implementation has been extended with an option to add reply quoting to the extracted part (this is implemented as a named flag to avoid naked booleans, even though it's the only flag it can take).
2012-03-27 23:59:50 +02:00
#include "gmime-filter-reply.h"
show: Associate an sprinter with each format This associates an sprinter constructor with each show format and uses this to construct the appropriate sprinter. Currently nothing is done with this sprinter, but the following patches will weave it through the layers of notmuch show.
2012-08-03 03:14:50 +02:00
#include "sprinter.h"
notmuch: Break notmuch.c up into several smaller files. Now that the client sources are alone here in their own directory, (with all the library sources down inside the lib directory), we can break the client up into multiple files without mixing the files up. The hope is that these smaller files will be easier to manage and maintain.
2009-11-10 21:03:05 +01:00
show: Allow formatters to return errors Formatter errors are propagated to the exit status of notmuch show. This isn't used by the JSON or text formatters, but it will be useful for the raw format, which is pickier.
2012-03-06 19:48:39 +01:00
static notmuch_status_t
show: Feed the sprinter down to part formatters There are several levels of function calls between where we create the sprinter and the call to the part formatter in show_message. This feeds the sprinter through all of them and into the part formatters.
2012-08-03 03:14:52 +02:00
format_part_text (const void *ctx, sprinter_t *sp, mime_node_t *node,
show: Convert text format to the new self-recursive style This is all code movement and a smidgen of glue. This moves the existing text formatter code into one self-recursive function, but doesn't change any of the logic. The next patch will actually take advantage of what the new structure has to offer. Note that this patch retains format_headers_message_part_text because it is also used by the raw format.
2012-02-04 22:24:25 +01:00
int indent, const notmuch_show_params_t *params);
notmuch show: Properly nest MIME parts within mulipart parts Previously, notmuch show flattened all output, losing information about the nesting of the MIME hierarchy. Now, the output is properly nested, (both in the --format=text and --format=json output), so that clients can analyze the original MIME structure. Internally, this required splitting the final closing delimiter out of the various show_part functions and putting it into a new show_part_end function instead. Also, the show_part function now accepts a new "first" argument that is set not only for the first MIME part of a message, but also for each first MIME part within a series of multipart parts. This "first" argument controls the omission of a preceding comma when printing a part (for json). Many thanks to David Edmondson <dme@dme.org> for originally identifying the lack of nesting in the json output and submitting an early implementation of this feature. Thanks as well to Jameson Graef Rollins <jrollins@finestructure.net> for carefully shepherding David's patches through a remarkably long review process, patiently explaining them, and providing a cleaned up series that led to this final implementation. Jameson also provided the new emacs code here.
2011-05-18 00:34:57 +02:00
pass entire format structure to various show_message functions Various show_message* functions require formatting functions, which were previously being passed individually as arguments. Since we will need to be needing to passing in more formatting function in the future (ie. for crypto support), we here modify things so that we just pass in the entire format structure. This will make things much simpler down the line as we need to pass in new format functions. We move the show_format structure into notmuch-client.c as notmuch_show_format. This also affects notmuch-reply.c, so we create a mostly-empty format_reply to pass the reply_part function to show_message_body.
2011-05-20 20:45:33 +02:00
static const notmuch_show_format_t format_text = {
show: Associate an sprinter with each format This associates an sprinter constructor with each show format and uses this to construct the appropriate sprinter. Currently nothing is done with this sprinter, but the following patches will weave it through the layers of notmuch show.
2012-08-03 03:14:50 +02:00
.new_sprinter = sprinter_text_create,
show: Convert text format to the new self-recursive style This is all code movement and a smidgen of glue. This moves the existing text formatter code into one self-recursive function, but doesn't change any of the logic. The next patch will actually take advantage of what the new structure has to offer. Note that this patch retains format_headers_message_part_text because it is also used by the raw format.
2012-02-04 22:24:25 +01:00
.part = format_part_text,
Add an "--format=(json|text)" command-line option to both notmuch-search and notmuch-show. In the case of notmuch-show, "--format=json" also implies "--entire-thread" as the thread structure is implicit in the emitted document tree. As a coincidence to the implementation, multipart message ID numbers are now incremented with each part printed. This changes the previous semantics, which were unclear and not necessary related to the actual ordering of the message parts.
2009-12-31 16:17:40 +01:00
};
show: Allow formatters to return errors Formatter errors are propagated to the exit status of notmuch show. This isn't used by the JSON or text formatters, but it will be useful for the raw format, which is pickier.
2012-03-06 19:48:39 +01:00
static notmuch_status_t
Rename the -json printer functions in notmuch-reply and notmuch-show to generic -sprinter functions. All the structured output functions in notmuch-reply and notmuch-show are renamed to a generic name (as they do not contain any json-specific code anyway). This patch is a preparation to actually using the new S-Expression sprinter in notmuch-reply and notmuch-show.
2012-12-06 22:12:12 +01:00
format_part_sprinter_entry (const void *ctx, sprinter_t *sp, mime_node_t *node,
int indent, const notmuch_show_params_t *params);
Add signature verification of PGP/MIME-signed parts with --verify. This is primarily for notmuch-show, although the functionality is added to show-message. Once signatures are processed a new part_sigstatus formatter is emitted, and the entire multipart/signed part is replaced with the contents of the signed part. At the moment only a json part_sigstatus formatting function is available. Emacs support to follow. The original work for this patch was done by Daniel Kahn Gillmor <dkg@fifthhorseman.net> whose help with this functionality I greatly appreciate.
2011-05-26 03:01:17 +02:00
pass entire format structure to various show_message functions Various show_message* functions require formatting functions, which were previously being passed individually as arguments. Since we will need to be needing to passing in more formatting function in the future (ie. for crypto support), we here modify things so that we just pass in the entire format structure. This will make things much simpler down the line as we need to pass in new format functions. We move the show_format structure into notmuch-client.c as notmuch_show_format. This also affects notmuch-reply.c, so we create a mostly-empty format_reply to pass the reply_part function to show_message_body.
2011-05-20 20:45:33 +02:00
static const notmuch_show_format_t format_json = {
show: Associate an sprinter with each format This associates an sprinter constructor with each show format and uses this to construct the appropriate sprinter. Currently nothing is done with this sprinter, but the following patches will weave it through the layers of notmuch show.
2012-08-03 03:14:50 +02:00
.new_sprinter = sprinter_json_create,
Rename the -json printer functions in notmuch-reply and notmuch-show to generic -sprinter functions. All the structured output functions in notmuch-reply and notmuch-show are renamed to a generic name (as they do not contain any json-specific code anyway). This patch is a preparation to actually using the new S-Expression sprinter in notmuch-reply and notmuch-show.
2012-12-06 22:12:12 +01:00
.part = format_part_sprinter_entry,
Add an "--format=(json|text)" command-line option to both notmuch-search and notmuch-show. In the case of notmuch-show, "--format=json" also implies "--entire-thread" as the thread structure is implicit in the emitted document tree. As a coincidence to the implementation, multipart message ID numbers are now incremented with each part printed. This changes the previous semantics, which were unclear and not necessary related to the actual ordering of the message parts.
2009-12-31 16:17:40 +01:00
};
Use the S-Expression structured printer in notmuch-show, notmuch-reply and notmuch-search. This patch uses the new S-Expression printer in the notmuch CLI (show, search and reply). You can now use --format=sexp for any of them.
2012-12-06 22:12:13 +01:00
static const notmuch_show_format_t format_sexp = {
.new_sprinter = sprinter_sexp_create,
.part = format_part_sprinter_entry,
};
show: Convert mbox format to new self-recursive style Given the lack of recursion, this is pretty easy.
2012-03-06 19:48:41 +01:00
static notmuch_status_t
show: Feed the sprinter down to part formatters There are several levels of function calls between where we create the sprinter and the call to the part formatter in show_message. This feeds the sprinter through all of them and into the part formatters.
2012-08-03 03:14:52 +02:00
format_part_mbox (const void *ctx, sprinter_t *sp, mime_node_t *node,
show: Convert mbox format to new self-recursive style Given the lack of recursion, this is pretty easy.
2012-03-06 19:48:41 +01:00
int indent, const notmuch_show_params_t *params);
notmuch show: Add a --format=mbox option We don't love the mbox format, but it's still sometimes the most practical way to share a collection of messages as a single file. Here we implement the "mboxrd" variant of the mbox file format. This variant applies reversible escaping by prefixing a '>' character to all lines in the email messages matching the regular expression: "^>*From " This allows the escaping to be reliably removed. A reader should remove a '>' from any line matching the regular expression: "^>>*From " More details on the mboxrd formats (and others as well) can be found here: http://homepage.ntlworld.com/jonathan.deboynepollard/FGA/mail-mbox-formats.html
2010-06-09 04:45:54 +02:00
pass entire format structure to various show_message functions Various show_message* functions require formatting functions, which were previously being passed individually as arguments. Since we will need to be needing to passing in more formatting function in the future (ie. for crypto support), we here modify things so that we just pass in the entire format structure. This will make things much simpler down the line as we need to pass in new format functions. We move the show_format structure into notmuch-client.c as notmuch_show_format. This also affects notmuch-reply.c, so we create a mostly-empty format_reply to pass the reply_part function to show_message_body.
2011-05-20 20:45:33 +02:00
static const notmuch_show_format_t format_mbox = {
show: Associate an sprinter with each format This associates an sprinter constructor with each show format and uses this to construct the appropriate sprinter. Currently nothing is done with this sprinter, but the following patches will weave it through the layers of notmuch show.
2012-08-03 03:14:50 +02:00
.new_sprinter = sprinter_text_create,
show: Convert mbox format to new self-recursive style Given the lack of recursion, this is pretty easy.
2012-03-06 19:48:41 +01:00
.part = format_part_mbox,
notmuch show: Add a --format=mbox option We don't love the mbox format, but it's still sometimes the most practical way to share a collection of messages as a single file. Here we implement the "mboxrd" variant of the mbox file format. This variant applies reversible escaping by prefixing a '>' character to all lines in the email messages matching the regular expression: "^>*From " This allows the escaping to be reliably removed. A reader should remove a '>' from any line matching the regular expression: "^>>*From " More details on the mboxrd formats (and others as well) can be found here: http://homepage.ntlworld.com/jonathan.deboynepollard/FGA/mail-mbox-formats.html
2010-06-09 04:45:54 +02:00
};
show: Convert raw format to the new self-recursive style, properly support interior parts This is fully compatible for root and leaf parts, but now has proper support for interior parts. This requires some design decisions that were guided by what I would want if I were to save a part. Specifically: - Leaf parts are printed without headers and with transfer decoding. This is what makes sense for saving attachments. (Furthermore, the transfer decoding is necessary since, without the headers, the caller would not be able to interpret non-transfer-decoded output.) - Message parts are printed with their message headers, but without enclosing part headers. This is what makes sense for saving a message as a whole (which is a message part) and for saving attached messages. This is symmetric for whole messages and for attached messages, though we special-case the whole message for performance reasons (and corner-case correctness reasons: given malformed input, GMime may not be able to reproduce it from the parsed representation). - Multipart parts are printed with their headers and all child parts. It's not clear what the best thing to do for multipart is, but this was the most natural to implement and can be justified because such parts can't be interpreted without their headers. As an added benefit, we can move the special-case code for part 0 into the raw formatter.
2012-03-06 19:48:43 +01:00
static notmuch_status_t
show: Feed the sprinter down to part formatters There are several levels of function calls between where we create the sprinter and the call to the part formatter in show_message. This feeds the sprinter through all of them and into the part formatters.
2012-08-03 03:14:52 +02:00
format_part_raw (unused (const void *ctx), sprinter_t *sp, mime_node_t *node,
show: Convert raw format to the new self-recursive style, properly support interior parts This is fully compatible for root and leaf parts, but now has proper support for interior parts. This requires some design decisions that were guided by what I would want if I were to save a part. Specifically: - Leaf parts are printed without headers and with transfer decoding. This is what makes sense for saving attachments. (Furthermore, the transfer decoding is necessary since, without the headers, the caller would not be able to interpret non-transfer-decoded output.) - Message parts are printed with their message headers, but without enclosing part headers. This is what makes sense for saving a message as a whole (which is a message part) and for saving attached messages. This is symmetric for whole messages and for attached messages, though we special-case the whole message for performance reasons (and corner-case correctness reasons: given malformed input, GMime may not be able to reproduce it from the parsed representation). - Multipart parts are printed with their headers and all child parts. It's not clear what the best thing to do for multipart is, but this was the most natural to implement and can be justified because such parts can't be interpreted without their headers. As an added benefit, we can move the special-case code for part 0 into the raw formatter.
2012-03-06 19:48:43 +01:00
unused (int indent),
unused (const notmuch_show_params_t *params));
New part output handling as option to notmuch-show. Outputting of single MIME parts is moved to an option of notmuch show, instead of being handled in it's own sub-command. The recent rework of multipart mime allowed for this change but consolidating part handling into a single recursive function (show_message_part) that includes formatting. This allows for far simpler handling single output of a single part, including formatting.
2011-05-24 00:31:32 +02:00
static const notmuch_show_format_t format_raw = {
show: Associate an sprinter with each format This associates an sprinter constructor with each show format and uses this to construct the appropriate sprinter. Currently nothing is done with this sprinter, but the following patches will weave it through the layers of notmuch show.
2012-08-03 03:14:50 +02:00
.new_sprinter = sprinter_text_create,
show: Convert raw format to the new self-recursive style, properly support interior parts This is fully compatible for root and leaf parts, but now has proper support for interior parts. This requires some design decisions that were guided by what I would want if I were to save a part. Specifically: - Leaf parts are printed without headers and with transfer decoding. This is what makes sense for saving attachments. (Furthermore, the transfer decoding is necessary since, without the headers, the caller would not be able to interpret non-transfer-decoded output.) - Message parts are printed with their message headers, but without enclosing part headers. This is what makes sense for saving a message as a whole (which is a message part) and for saving attached messages. This is symmetric for whole messages and for attached messages, though we special-case the whole message for performance reasons (and corner-case correctness reasons: given malformed input, GMime may not be able to reproduce it from the parsed representation). - Multipart parts are printed with their headers and all child parts. It's not clear what the best thing to do for multipart is, but this was the most natural to implement and can be justified because such parts can't be interpreted without their headers. As an added benefit, we can move the special-case code for part 0 into the raw formatter.
2012-03-06 19:48:43 +01:00
.part = format_part_raw,
New part output handling as option to notmuch-show. Outputting of single MIME parts is moved to an option of notmuch show, instead of being handled in it's own sub-command. The recent rework of multipart mime allowed for this change but consolidating part handling into a single recursive function (show_message_part) that includes formatting. This allows for far simpler handling single output of a single part, including formatting.
2011-05-24 00:31:32 +02:00
};
notmuch: Break notmuch.c up into several smaller files. Now that the client sources are alone here in their own directory, (with all the library sources down inside the lib directory), we can break the client up into multiple files without mixing the files up. The hope is that these smaller files will be easier to manage and maintain.
2009-11-10 21:03:05 +01:00
static const char *
Add an "--format=(json|text)" command-line option to both notmuch-search and notmuch-show. In the case of notmuch-show, "--format=json" also implies "--entire-thread" as the thread structure is implicit in the emitted document tree. As a coincidence to the implementation, multipart message ID numbers are now incremented with each part printed. This changes the previous semantics, which were unclear and not necessary related to the actual ordering of the message parts.
2009-12-31 16:17:40 +01:00
_get_tags_as_string (const void *ctx, notmuch_message_t *message)
notmuch: Break notmuch.c up into several smaller files. Now that the client sources are alone here in their own directory, (with all the library sources down inside the lib directory), we can break the client up into multiple files without mixing the files up. The hope is that these smaller files will be easier to manage and maintain.
2009-11-10 21:03:05 +01:00
{
notmuch_tags_t *tags;
int first = 1;
const char *tag;
char *result;
result = talloc_strdup (ctx, "");
if (result == NULL)
return NULL;
for (tags = notmuch_message_get_tags (message);
lib: Rename iterator functions to prepare for reverse iteration. We rename 'has_more' to 'valid' so that it can function whether iterating in a forward or reverse direction. We also rename 'advance' to 'move_to_next' to setup parallel naming with the proposed functions 'move_to_first', 'move_to_last', and 'move_to_previous'.
2010-03-09 18:22:29 +01:00
notmuch_tags_valid (tags);
notmuch_tags_move_to_next (tags))
notmuch: Break notmuch.c up into several smaller files. Now that the client sources are alone here in their own directory, (with all the library sources down inside the lib directory), we can break the client up into multiple files without mixing the files up. The hope is that these smaller files will be easier to manage and maintain.
2009-11-10 21:03:05 +01:00
{
tag = notmuch_tags_get (tags);
result = talloc_asprintf_append (result, "%s%s",
first ? "" : " ", tag);
first = 0;
}
return result;
}
/* Get a nice, single-line summary of message. */
static const char *
Add an "--format=(json|text)" command-line option to both notmuch-search and notmuch-show. In the case of notmuch-show, "--format=json" also implies "--entire-thread" as the thread structure is implicit in the emitted document tree. As a coincidence to the implementation, multipart message ID numbers are now incremented with each part printed. This changes the previous semantics, which were unclear and not necessary related to the actual ordering of the message parts.
2009-12-31 16:17:40 +01:00
_get_one_line_summary (const void *ctx, notmuch_message_t *message)
notmuch: Break notmuch.c up into several smaller files. Now that the client sources are alone here in their own directory, (with all the library sources down inside the lib directory), we can break the client up into multiple files without mixing the files up. The hope is that these smaller files will be easier to manage and maintain.
2009-11-10 21:03:05 +01:00
{
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);
}
cli/show: abstract get content disposition Reduce duplication in follow-up work. As a side effect, handle error returns from g_mime_content_disposition_get_disposition() without segfaulting.
2017-02-26 19:33:47 +01:00
static const char *_get_disposition(GMimeObject *meta)
{
GMimeContentDisposition *disposition;
disposition = g_mime_object_get_content_disposition (meta);
if (!disposition)
return NULL;
return g_mime_content_disposition_get_disposition (disposition);
}
show: Convert envelope format_part_json to use sprinter
2012-08-03 03:14:56 +02:00
/* Emit a sequence of key/value pairs for the metadata of message.
* The caller should begin a map before calling this. */
Add an "--format=(json|text)" command-line option to both notmuch-search and notmuch-show. In the case of notmuch-show, "--format=json" also implies "--entire-thread" as the thread structure is implicit in the emitted document tree. As a coincidence to the implementation, multipart message ID numbers are now incremented with each part printed. This changes the previous semantics, which were unclear and not necessary related to the actual ordering of the message parts.
2009-12-31 16:17:40 +01:00
static void
Rename the -json printer functions in notmuch-reply and notmuch-show to generic -sprinter functions. All the structured output functions in notmuch-reply and notmuch-show are renamed to a generic name (as they do not contain any json-specific code anyway). This patch is a preparation to actually using the new S-Expression sprinter in notmuch-reply and notmuch-show.
2012-12-06 22:12:12 +01:00
format_message_sprinter (sprinter_t *sp, notmuch_message_t *message)
Add an "--format=(json|text)" command-line option to both notmuch-search and notmuch-show. In the case of notmuch-show, "--format=json" also implies "--entire-thread" as the thread structure is implicit in the emitted document tree. As a coincidence to the implementation, multipart message ID numbers are now incremented with each part printed. This changes the previous semantics, which were unclear and not necessary related to the actual ordering of the message parts.
2009-12-31 16:17:40 +01:00
{
Use the S-Expression structured printer in notmuch-show, notmuch-reply and notmuch-search. This patch uses the new S-Expression printer in the notmuch CLI (show, search and reply). You can now use --format=sexp for any of them.
2012-12-06 22:12:13 +01:00
/* Any changes to the JSON or S-Expression format should be
* reflected in the file devel/schemata. */
show: More aggressively document the presence of devel/schemata Previously, the only mention of devel/schemata was a comment at the top of format_part_json, but the JSON output code is spread across several functions that are distributed across notmuch-show.c. Add references from the other three key JSON output functions.
2012-11-07 16:27:01 +01:00
show: Convert envelope format_part_json to use sprinter
2012-08-03 03:14:56 +02:00
void *local = talloc_new (NULL);
notmuch-show: add tags to json output The previous json patches forgot to add the notmuch tags to the json output. This is inconsistent to the text output so here they are. We just output a 'tags' field that sends notmuch tags as a json array. Signed-off-by: Sebastian Spaeth <Sebastian@SSpaeth.de>
2010-03-11 13:11:43 +01:00
notmuch_tags_t *tags;
notmuch-show: Add unix and relative dates to the JSON output Include a 'date_unix' and 'date_relative' field in the JSON output for each message. 'date_relative' can be used by a UI implementation, whereas 'date_unix' is useful when scripting.
2010-03-23 10:40:48 +01:00
time_t date;
const char *relative_date;
show: Convert envelope format_part_json to use sprinter
2012-08-03 03:14:56 +02:00
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");
cli/show: list all filenames of a message in the formatted output Instead of just having the first filename for the message, list all duplicate filenames of the message as a list in the formatted outputs. This bumps the format version to 3.
2017-02-25 14:31:31 +01:00
if (notmuch_format_version >= 3) {
notmuch_filenames_t *filenames;
sp->begin_list (sp);
for (filenames = notmuch_message_get_filenames (message);
notmuch_filenames_valid (filenames);
notmuch_filenames_move_to_next (filenames)) {
sp->string (sp, notmuch_filenames_get (filenames));
}
notmuch_filenames_destroy (filenames);
sp->end (sp);
} else {
sp->string (sp, notmuch_message_get_filename (message));
}
show: Convert envelope format_part_json to use sprinter
2012-08-03 03:14:56 +02:00
sp->map_key (sp, "timestamp");
notmuch-show: Add unix and relative dates to the JSON output Include a 'date_unix' and 'date_relative' field in the JSON output for each message. 'date_relative' can be used by a UI implementation, whereas 'date_unix' is useful when scripting.
2010-03-23 10:40:48 +01:00
date = notmuch_message_get_date (message);
show: Convert envelope format_part_json to use sprinter
2012-08-03 03:14:56 +02:00
sp->integer (sp, date);
Add an "--format=(json|text)" command-line option to both notmuch-search and notmuch-show. In the case of notmuch-show, "--format=json" also implies "--entire-thread" as the thread structure is implicit in the emitted document tree. As a coincidence to the implementation, multipart message ID numbers are now incremented with each part printed. This changes the previous semantics, which were unclear and not necessary related to the actual ordering of the message parts.
2009-12-31 16:17:40 +01:00
show: Convert envelope format_part_json to use sprinter
2012-08-03 03:14:56 +02:00
sp->map_key (sp, "date_relative");
relative_date = notmuch_time_relative_date (local, date);
sp->string (sp, relative_date);
Add an "--format=(json|text)" command-line option to both notmuch-search and notmuch-show. In the case of notmuch-show, "--format=json" also implies "--entire-thread" as the thread structure is implicit in the emitted document tree. As a coincidence to the implementation, multipart message ID numbers are now incremented with each part printed. This changes the previous semantics, which were unclear and not necessary related to the actual ordering of the message parts.
2009-12-31 16:17:40 +01:00
show: Convert envelope format_part_json to use sprinter
2012-08-03 03:14:56 +02:00
sp->map_key (sp, "tags");
sp->begin_list (sp);
notmuch-show: add tags to json output The previous json patches forgot to add the notmuch tags to the json output. This is inconsistent to the text output so here they are. We just output a 'tags' field that sends notmuch tags as a json array. Signed-off-by: Sebastian Spaeth <Sebastian@SSpaeth.de>
2010-03-11 13:11:43 +01:00
for (tags = notmuch_message_get_tags (message);
notmuch_tags_valid (tags);
notmuch_tags_move_to_next (tags))
show: Convert envelope format_part_json to use sprinter
2012-08-03 03:14:56 +02:00
sp->string (sp, notmuch_tags_get (tags));
sp->end (sp);
talloc_free (local);
Add an "--format=(json|text)" command-line option to both notmuch-search and notmuch-show. In the case of notmuch-show, "--format=json" also implies "--entire-thread" as the thread structure is implicit in the emitted document tree. As a coincidence to the implementation, multipart message ID numbers are now incremented with each part printed. This changes the previous semantics, which were unclear and not necessary related to the actual ordering of the message parts.
2009-12-31 16:17:40 +01:00
}
notmuch show: Add a --format=mbox option We don't love the mbox format, but it's still sometimes the most practical way to share a collection of messages as a single file. Here we implement the "mboxrd" variant of the mbox file format. This variant applies reversible escaping by prefixing a '>' character to all lines in the email messages matching the regular expression: "^>*From " This allows the escaping to be reliably removed. A reader should remove a '>' from any line matching the regular expression: "^>>*From " More details on the mboxrd formats (and others as well) can be found here: http://homepage.ntlworld.com/jonathan.deboynepollard/FGA/mail-mbox-formats.html
2010-06-09 04:45:54 +02:00
/* Extract just the email address from the contents of a From:
* header. */
static const char *
_extract_email_address (const void *ctx, const char *from)
{
InternetAddressList *addresses;
InternetAddress *address;
InternetAddressMailbox *mailbox;
const char *email = "MAILER-DAEMON";
addresses = internet_address_list_parse_string (from);
/* Bail if there is no address here. */
if (addresses == NULL || internet_address_list_length (addresses) < 1)
goto DONE;
/* Otherwise, just use the first address. */
address = internet_address_list_get_address (addresses, 0);
/* The From header should never contain an address group rather
* than a mailbox. So bail if it does. */
if (! INTERNET_ADDRESS_IS_MAILBOX (address))
goto DONE;
mailbox = INTERNET_ADDRESS_MAILBOX (address);
email = internet_address_mailbox_get_addr (mailbox);
email = talloc_strdup (ctx, email);
DONE:
Release memory allocated by internet_address_list_parse_string() g_object_unref() releases the memory of the InternetAddressList object returned by internet_address_list_parse_string() -- when last (only) reference is released, internet_address_list_finalize() will do cleanup.
2011-12-10 11:18:54 +01:00
if (addresses)
g_object_unref (addresses);
notmuch show: Add a --format=mbox option We don't love the mbox format, but it's still sometimes the most practical way to share a collection of messages as a single file. Here we implement the "mboxrd" variant of the mbox file format. This variant applies reversible escaping by prefixing a '>' character to all lines in the email messages matching the regular expression: "^>*From " This allows the escaping to be reliably removed. A reader should remove a '>' from any line matching the regular expression: "^>>*From " More details on the mboxrd formats (and others as well) can be found here: http://homepage.ntlworld.com/jonathan.deboynepollard/FGA/mail-mbox-formats.html
2010-06-09 04:45:54 +02:00
return email;
}
/* Return 1 if 'line' is an mbox From_ line---that is, a line
* beginning with zero or more '>' characters followed by the
* characters 'F', 'r', 'o', 'm', and space.
*
* Any characters at all may appear after that in the line.
*/
static int
_is_from_line (const char *line)
{
const char *s = line;
if (line == NULL)
return 0;
while (*s == '>')
s++;
if (STRNCMP_LITERAL (s, "From ") == 0)
return 1;
else
return 0;
}
reply: Add a JSON reply format. This new JSON format for replies includes headers generated for a reply message as well as the headers of the original message. Using this data, a client can intelligently create a reply. For example, the emacs client will be able to create replies with quoted HTML parts by parsing the HTML parts.
2012-03-18 17:32:36 +01:00
void
Rename the -json printer functions in notmuch-reply and notmuch-show to generic -sprinter functions. All the structured output functions in notmuch-reply and notmuch-show are renamed to a generic name (as they do not contain any json-specific code anyway). This patch is a preparation to actually using the new S-Expression sprinter in notmuch-reply and notmuch-show.
2012-12-06 22:12:12 +01:00
format_headers_sprinter (sprinter_t *sp, GMimeMessage *message,
notmuch_bool_t reply)
Improve handling of message/rfc822 parts by adding a new header_message_part function to the formating structure. This new function takes a GMimeMessage as input, and outputs the formatted headers. This allows for message/rfc822 parts to be formatted on output in a similar way to full messages (see previous patch that overhauls the multipart test for more info).
2011-06-06 02:29:28 +02:00
{
Use the S-Expression structured printer in notmuch-show, notmuch-reply and notmuch-search. This patch uses the new S-Expression printer in the notmuch CLI (show, search and reply). You can now use --format=sexp for any of them.
2012-12-06 22:12:13 +01:00
/* Any changes to the JSON or S-Expression format should be
* reflected in the file devel/schemata. */
show: More aggressively document the presence of devel/schemata Previously, the only mention of devel/schemata was a comment at the top of format_part_json, but the JSON output code is spread across several functions that are distributed across notmuch-show.c. Add references from the other three key JSON output functions.
2012-11-07 16:27:01 +01:00
Improve handling of message/rfc822 parts by adding a new header_message_part function to the formating structure. This new function takes a GMimeMessage as input, and outputs the formatted headers. This allows for message/rfc822 parts to be formatted on output in a similar way to full messages (see previous patch that overhauls the multipart test for more info).
2011-06-06 02:29:28 +02:00
InternetAddressList *recipients;
fix memory leaks in notmuch-show.c:format_headers_sprinter() Internet_address_list_to_string() and g_mime_message_get_date_as_string() return allocated string buffers and not const, so from what I can tell from taking a look at the sprinter-sexp.c’s sexp_string() function, the code leaks the recipients_string as well as the date string.
2017-03-16 17:53:47 +01:00
char *recipients_string;
show: include Reply-To header in json output Output the Reply-To header field if present in a message. I want to be able to see what the sender intended in my mail client, before hitting the reply key. Only json output is changed, like the recently added Bcc field.
2012-10-30 11:12:46 +01:00
const char *reply_to_string;
fix memory leaks in notmuch-show.c:format_headers_sprinter() Internet_address_list_to_string() and g_mime_message_get_date_as_string() return allocated string buffers and not const, so from what I can tell from taking a look at the sprinter-sexp.c’s sexp_string() function, the code leaks the recipients_string as well as the date string.
2017-03-16 17:53:47 +01:00
char *date_string;
Improve handling of message/rfc822 parts by adding a new header_message_part function to the formating structure. This new function takes a GMimeMessage as input, and outputs the formatted headers. This allows for message/rfc822 parts to be formatted on output in a similar way to full messages (see previous patch that overhauls the multipart test for more info).
2011-06-06 02:29:28 +02:00
show: Convert format_headers_json to use sprinter This no longer requires a talloc context (not that it really did before since it didn't return anything), so we remove its context argument.
2012-08-03 03:14:53 +02:00
sp->begin_map (sp);
sp->map_key (sp, "Subject");
sp->string (sp, g_mime_message_get_subject (message));
sp->map_key (sp, "From");
sp->string (sp, g_mime_message_get_sender (message));
Improve handling of message/rfc822 parts by adding a new header_message_part function to the formating structure. This new function takes a GMimeMessage as input, and outputs the formatted headers. This allows for message/rfc822 parts to be formatted on output in a similar way to full messages (see previous patch that overhauls the multipart test for more info).
2011-06-06 02:29:28 +02:00
recipients = g_mime_message_get_recipients (message, GMIME_RECIPIENT_TYPE_TO);
recipients_string = internet_address_list_to_string (recipients, 0);
show: Convert format_headers_json to use sprinter This no longer requires a talloc context (not that it really did before since it didn't return anything), so we remove its context argument.
2012-08-03 03:14:53 +02:00
if (recipients_string) {
sp->map_key (sp, "To");
sp->string (sp, recipients_string);
fix memory leaks in notmuch-show.c:format_headers_sprinter() Internet_address_list_to_string() and g_mime_message_get_date_as_string() return allocated string buffers and not const, so from what I can tell from taking a look at the sprinter-sexp.c’s sexp_string() function, the code leaks the recipients_string as well as the date string.
2017-03-16 17:53:47 +01:00
g_free (recipients_string);
show: Convert format_headers_json to use sprinter This no longer requires a talloc context (not that it really did before since it didn't return anything), so we remove its context argument.
2012-08-03 03:14:53 +02:00
}
Improve handling of message/rfc822 parts by adding a new header_message_part function to the formating structure. This new function takes a GMimeMessage as input, and outputs the formatted headers. This allows for message/rfc822 parts to be formatted on output in a similar way to full messages (see previous patch that overhauls the multipart test for more info).
2011-06-06 02:29:28 +02:00
recipients = g_mime_message_get_recipients (message, GMIME_RECIPIENT_TYPE_CC);
recipients_string = internet_address_list_to_string (recipients, 0);
show: Convert format_headers_json to use sprinter This no longer requires a talloc context (not that it really did before since it didn't return anything), so we remove its context argument.
2012-08-03 03:14:53 +02:00
if (recipients_string) {
sp->map_key (sp, "Cc");
sp->string (sp, recipients_string);
fix memory leaks in notmuch-show.c:format_headers_sprinter() Internet_address_list_to_string() and g_mime_message_get_date_as_string() return allocated string buffers and not const, so from what I can tell from taking a look at the sprinter-sexp.c’s sexp_string() function, the code leaks the recipients_string as well as the date string.
2017-03-16 17:53:47 +01:00
g_free (recipients_string);
show: Convert format_headers_json to use sprinter This no longer requires a talloc context (not that it really did before since it didn't return anything), so we remove its context argument.
2012-08-03 03:14:53 +02:00
}
reply: Add a JSON reply format. This new JSON format for replies includes headers generated for a reply message as well as the headers of the original message. Using this data, a client can intelligently create a reply. For example, the emacs client will be able to create replies with quoted HTML parts by parsing the HTML parts.
2012-03-18 17:32:36 +01:00
notmuch-show: include Bcc header in json output With this change, emacs users can use notmuch-message-headers variable to configure notmuch-show display Bcc header.
2012-09-10 08:35:30 +02:00
recipients = g_mime_message_get_recipients (message, GMIME_RECIPIENT_TYPE_BCC);
recipients_string = internet_address_list_to_string (recipients, 0);
if (recipients_string) {
sp->map_key (sp, "Bcc");
sp->string (sp, recipients_string);
fix memory leaks in notmuch-show.c:format_headers_sprinter() Internet_address_list_to_string() and g_mime_message_get_date_as_string() return allocated string buffers and not const, so from what I can tell from taking a look at the sprinter-sexp.c’s sexp_string() function, the code leaks the recipients_string as well as the date string.
2017-03-16 17:53:47 +01:00
g_free (recipients_string);
notmuch-show: include Bcc header in json output With this change, emacs users can use notmuch-message-headers variable to configure notmuch-show display Bcc header.
2012-09-10 08:35:30 +02:00
}
show: include Reply-To header in json output Output the Reply-To header field if present in a message. I want to be able to see what the sender intended in my mail client, before hitting the reply key. Only json output is changed, like the recently added Bcc field.
2012-10-30 11:12:46 +01:00
reply_to_string = g_mime_message_get_reply_to (message);
if (reply_to_string) {
sp->map_key (sp, "Reply-To");
sp->string (sp, reply_to_string);
}
reply: Add a JSON reply format. This new JSON format for replies includes headers generated for a reply message as well as the headers of the original message. Using this data, a client can intelligently create a reply. For example, the emacs client will be able to create replies with quoted HTML parts by parsing the HTML parts.
2012-03-18 17:32:36 +01:00
if (reply) {
show: Convert format_headers_json to use sprinter This no longer requires a talloc context (not that it really did before since it didn't return anything), so we remove its context argument.
2012-08-03 03:14:53 +02:00
sp->map_key (sp, "In-reply-to");
sp->string (sp, g_mime_object_get_header (GMIME_OBJECT (message), "In-reply-to"));
reply: Add a JSON reply format. This new JSON format for replies includes headers generated for a reply message as well as the headers of the original message. Using this data, a client can intelligently create a reply. For example, the emacs client will be able to create replies with quoted HTML parts by parsing the HTML parts.
2012-03-18 17:32:36 +01:00
show: Convert format_headers_json to use sprinter This no longer requires a talloc context (not that it really did before since it didn't return anything), so we remove its context argument.
2012-08-03 03:14:53 +02:00
sp->map_key (sp, "References");
sp->string (sp, g_mime_object_get_header (GMIME_OBJECT (message), "References"));
reply: Add a JSON reply format. This new JSON format for replies includes headers generated for a reply message as well as the headers of the original message. Using this data, a client can intelligently create a reply. For example, the emacs client will be able to create replies with quoted HTML parts by parsing the HTML parts.
2012-03-18 17:32:36 +01:00
} else {
show: Convert format_headers_json to use sprinter This no longer requires a talloc context (not that it really did before since it didn't return anything), so we remove its context argument.
2012-08-03 03:14:53 +02:00
sp->map_key (sp, "Date");
fix memory leaks in notmuch-show.c:format_headers_sprinter() Internet_address_list_to_string() and g_mime_message_get_date_as_string() return allocated string buffers and not const, so from what I can tell from taking a look at the sprinter-sexp.c’s sexp_string() function, the code leaks the recipients_string as well as the date string.
2017-03-16 17:53:47 +01:00
date_string = g_mime_message_get_date_as_string (message);
sp->string (sp, date_string);
g_free (date_string);
reply: Add a JSON reply format. This new JSON format for replies includes headers generated for a reply message as well as the headers of the original message. Using this data, a client can intelligently create a reply. For example, the emacs client will be able to create replies with quoted HTML parts by parsing the HTML parts.
2012-03-18 17:32:36 +01:00
}
show: Convert format_headers_json to use sprinter This no longer requires a talloc context (not that it really did before since it didn't return anything), so we remove its context argument.
2012-08-03 03:14:53 +02:00
sp->end (sp);
Improve handling of message/rfc822 parts by adding a new header_message_part function to the formating structure. This new function takes a GMimeMessage as input, and outputs the formatted headers. This allows for message/rfc822 parts to be formatted on output in a similar way to full messages (see previous patch that overhauls the multipart test for more info).
2011-06-06 02:29:28 +02:00
}
notmuch show: Don't do text conversions for non-text parts This fixes the recently-added test case (in test/multipart) demonstrating corruption of binary parts that happen to contain CRLF pairs. We restore the original code from show_one_part_content to format_part_content_raw. Then, for good measure, we rename show_part_content to the more descriptive show_text_part_content and add an internal error if it is ever called with a non-text part.
2011-06-01 01:13:21 +02:00
/* Write a MIME text part out to the given stream.
show/reply: Unify the code that extracts text parts Previously, show and reply had separate implementations of decoding and printing text parts. Now both use show's implementation, which was more complete. Show's implementation has been extended with an option to add reply quoting to the extracted part (this is implemented as a named flag to avoid naked booleans, even though it's the only flag it can take).
2012-03-27 23:59:50 +02:00
*
* If (flags & NOTMUCH_SHOW_TEXT_PART_REPLY), this prepends "> " to
* each output line.
notmuch show: Don't do text conversions for non-text parts This fixes the recently-added test case (in test/multipart) demonstrating corruption of binary parts that happen to contain CRLF pairs. We restore the original code from show_one_part_content to format_part_content_raw. Then, for good measure, we rename show_part_content to the more descriptive show_text_part_content and add an internal error if it is ever called with a non-text part.
2011-06-01 01:13:21 +02:00
*
* Both line-ending conversion (CRLF->LF) and charset conversion ( ->
* UTF-8) will be performed, so it is inappropriate to call this
* function with a non-text part. Doing so will trigger an internal
* error.
*/
show/reply: Unify the code that extracts text parts Previously, show and reply had separate implementations of decoding and printing text parts. Now both use show's implementation, which was more complete. Show's implementation has been extended with an option to add reply quoting to the extracted part (this is implemented as a named flag to avoid naked booleans, even though it's the only flag it can take).
2012-03-27 23:59:50 +02:00
void
show_text_part_content (GMimeObject *part, GMimeStream *stream_out,
notmuch_show_text_part_flags flags)
notmuch show: Don't hide text parts, even with disposition attachment. If it's text, (such as a patch), then I want to see it.
2009-11-21 01:09:36 +01:00
{
notmuch show: Don't do text conversions for non-text parts This fixes the recently-added test case (in test/multipart) demonstrating corruption of binary parts that happen to contain CRLF pairs. We restore the original code from show_one_part_content to format_part_content_raw. Then, for good measure, we rename show_part_content to the more descriptive show_text_part_content and add an internal error if it is ever called with a non-text part.
2011-06-01 01:13:21 +02:00
GMimeContentType *content_type = g_mime_object_get_content_type (GMIME_OBJECT (part));
notmuch show: Don't hide text parts, even with disposition attachment. If it's text, (such as a patch), then I want to see it.
2009-11-21 01:09:36 +01:00
GMimeStream *stream_filter = NULL;
cli/show: unref crlf filter. Mimic the handling of the other filter g_objects. This cleans up a fair sized memory leak.
2017-03-18 18:46:42 +01:00
GMimeFilter *crlf_filter = NULL;
notmuch show: Don't hide text parts, even with disposition attachment. If it's text, (such as a patch), then I want to see it.
2009-11-21 01:09:36 +01:00
GMimeDataWrapper *wrapper;
notmuch-show: Show message part using UTF-8. Pass the message through the charset filter so that we can view messages wrote in different charset encoding. Signed-off-by: Kan-Ru Chen <kanru@kanru.info>
2009-11-22 09:30:47 +01:00
const char *charset;
notmuch show: Don't do text conversions for non-text parts This fixes the recently-added test case (in test/multipart) demonstrating corruption of binary parts that happen to contain CRLF pairs. We restore the original code from show_one_part_content to format_part_content_raw. Then, for good measure, we rename show_part_content to the more descriptive show_text_part_content and add an internal error if it is ever called with a non-text part.
2011-06-01 01:13:21 +02:00
if (! g_mime_content_type_is_type (content_type, "text", "*"))
INTERNAL_ERROR ("Illegal request to format non-text part (%s) as text.",
g_mime_content_type_to_string (content_type));
Reduce some excessive indentation. I prefer checking a condition and returning early rather than making large blocks of code within a function conditional.
2011-06-01 01:18:45 +02:00
if (stream_out == NULL)
return;
notmuch show: Don't hide text parts, even with disposition attachment. If it's text, (such as a patch), then I want to see it.
2009-11-21 01:09:36 +01:00
Reduce some excessive indentation. I prefer checking a condition and returning early rather than making large blocks of code within a function conditional.
2011-06-01 01:18:45 +02:00
stream_filter = g_mime_stream_filter_new (stream_out);
cli/show: unref crlf filter. Mimic the handling of the other filter g_objects. This cleans up a fair sized memory leak.
2017-03-18 18:46:42 +01:00
crlf_filter = g_mime_filter_crlf_new (FALSE, FALSE);
Reduce some excessive indentation. I prefer checking a condition and returning early rather than making large blocks of code within a function conditional.
2011-06-01 01:18:45 +02:00
g_mime_stream_filter_add(GMIME_STREAM_FILTER (stream_filter),
cli/show: unref crlf filter. Mimic the handling of the other filter g_objects. This cleans up a fair sized memory leak.
2017-03-18 18:46:42 +01:00
crlf_filter);
g_object_unref (crlf_filter);
Reduce some excessive indentation. I prefer checking a condition and returning early rather than making large blocks of code within a function conditional.
2011-06-01 01:18:45 +02:00
charset = g_mime_object_get_content_type_parameter (part, "charset");
if (charset) {
GMimeFilter *charset_filter;
charset_filter = g_mime_filter_charset_new (charset, "UTF-8");
/* This result can be NULL for things like "unknown-8bit".
* Don't set a NULL filter as that makes GMime print
* annoying assertion-failure messages on stderr. */
notmuch: unref charset_filter to fix one memory leak In my test case added g_object_unref(charset_filter) reduces memory consumption over 90% when 'notmuch show --format=text "*"' is executed (~11000 messages, RES ~330M -> ~25M).
2011-12-13 19:18:48 +01:00
if (charset_filter) {
Reduce some excessive indentation. I prefer checking a condition and returning early rather than making large blocks of code within a function conditional.
2011-06-01 01:18:45 +02:00
g_mime_stream_filter_add (GMIME_STREAM_FILTER (stream_filter),
charset_filter);
notmuch: unref charset_filter to fix one memory leak In my test case added g_object_unref(charset_filter) reduces memory consumption over 90% when 'notmuch show --format=text "*"' is executed (~11000 messages, RES ~330M -> ~25M).
2011-12-13 19:18:48 +01:00
g_object_unref (charset_filter);
}
notmuch show: Don't hide text parts, even with disposition attachment. If it's text, (such as a patch), then I want to see it.
2009-11-21 01:09:36 +01:00
}
show/reply: Unify the code that extracts text parts Previously, show and reply had separate implementations of decoding and printing text parts. Now both use show's implementation, which was more complete. Show's implementation has been extended with an option to add reply quoting to the extracted part (this is implemented as a named flag to avoid naked booleans, even though it's the only flag it can take).
2012-03-27 23:59:50 +02:00
if (flags & NOTMUCH_SHOW_TEXT_PART_REPLY) {
GMimeFilter *reply_filter;
reply_filter = g_mime_filter_reply_new (TRUE);
if (reply_filter) {
g_mime_stream_filter_add (GMIME_STREAM_FILTER (stream_filter),
reply_filter);
g_object_unref (reply_filter);
}
}
notmuch show: Don't hide text parts, even with disposition attachment. If it's text, (such as a patch), then I want to see it.
2009-11-21 01:09:36 +01:00
wrapper = g_mime_part_get_content_object (GMIME_PART (part));
if (wrapper && stream_filter)
g_mime_data_wrapper_write_to_stream (wrapper, stream_filter);
if (stream_filter)
g_object_unref(stream_filter);
}
cli: conform to same conditional build style as elsewhere in notmuch-show Conform to the same style for #ifdef GMIME_ATLEAST_26 conditional builds as elsewhere. There are no functional changes.
2013-03-30 14:53:17 +01:00
/* Get signature status string (GMime 2.6) */
Add compatibility with gmime 2.6 There are lots of API changes in gmime 2.6 crypto handling. By adding preprocessor directives, it is however possible to add gmime 2.6 compatibility while preserving compatibility with gmime 2.4 too. This is mostly based on id:"8762i8hrb9.fsf@bookbinder.fernseed.info". This was tested against both gmime 2.6.4 and 2.4.31. With gmime 2.4.31, the crypto tests all work fine (as expected). With gmime 2.6.4, one crypto test is currently broken (signature verification with signer key unavailable), most likely because of a bug in gmime which will hopefully be fixed in a future version.
2012-01-20 10:39:24 +01:00
static const char*
signature_status_to_string (GMimeSignatureStatus x)
{
switch (x) {
case GMIME_SIGNATURE_STATUS_GOOD:
return "good";
case GMIME_SIGNATURE_STATUS_BAD:
return "bad";
case GMIME_SIGNATURE_STATUS_ERROR:
return "error";
}
return "unknown";
}
Add signature verification of PGP/MIME-signed parts with --verify. This is primarily for notmuch-show, although the functionality is added to show-message. Once signatures are processed a new part_sigstatus formatter is emitted, and the entire multipart/signed part is replaced with the contents of the signed part. At the moment only a json part_sigstatus formatting function is available. Emacs support to follow. The original work for this patch was done by Daniel Kahn Gillmor <dkg@fifthhorseman.net> whose help with this functionality I greatly appreciate.
2011-05-26 03:01:17 +02:00
cli: conform to same conditional build style as elsewhere in notmuch-show Conform to the same style for #ifdef GMIME_ATLEAST_26 conditional builds as elsewhere. There are no functional changes.
2013-03-30 14:53:17 +01:00
/* Signature status sprinter (GMime 2.6) */
Add compatibility with gmime 2.6 There are lots of API changes in gmime 2.6 crypto handling. By adding preprocessor directives, it is however possible to add gmime 2.6 compatibility while preserving compatibility with gmime 2.4 too. This is mostly based on id:"8762i8hrb9.fsf@bookbinder.fernseed.info". This was tested against both gmime 2.6.4 and 2.4.31. With gmime 2.4.31, the crypto tests all work fine (as expected). With gmime 2.6.4, one crypto test is currently broken (signature verification with signer key unavailable), most likely because of a bug in gmime which will hopefully be fixed in a future version.
2012-01-20 10:39:24 +01:00
static void
Rename the -json printer functions in notmuch-reply and notmuch-show to generic -sprinter functions. All the structured output functions in notmuch-reply and notmuch-show are renamed to a generic name (as they do not contain any json-specific code anyway). This patch is a preparation to actually using the new S-Expression sprinter in notmuch-reply and notmuch-show.
2012-12-06 22:12:12 +01:00
format_part_sigstatus_sprinter (sprinter_t *sp, mime_node_t *node)
Add compatibility with gmime 2.6 There are lots of API changes in gmime 2.6 crypto handling. By adding preprocessor directives, it is however possible to add gmime 2.6 compatibility while preserving compatibility with gmime 2.4 too. This is mostly based on id:"8762i8hrb9.fsf@bookbinder.fernseed.info". This was tested against both gmime 2.6.4 and 2.4.31. With gmime 2.4.31, the crypto tests all work fine (as expected). With gmime 2.6.4, one crypto test is currently broken (signature verification with signer key unavailable), most likely because of a bug in gmime which will hopefully be fixed in a future version.
2012-01-20 10:39:24 +01:00
{
Use the S-Expression structured printer in notmuch-show, notmuch-reply and notmuch-search. This patch uses the new S-Expression printer in the notmuch CLI (show, search and reply). You can now use --format=sexp for any of them.
2012-12-06 22:12:13 +01:00
/* Any changes to the JSON or S-Expression format should be
* reflected in the file devel/schemata. */
show: More aggressively document the presence of devel/schemata Previously, the only mention of devel/schemata was a comment at the top of format_part_json, but the JSON output code is spread across several functions that are distributed across notmuch-show.c. Add references from the other three key JSON output functions.
2012-11-07 16:27:01 +01:00
show: Make format_part_sigstatus_json's API consistent between GMIME 2.4 and 2.6 The implementation is still different for GMIME 2.4 and 2.6, but at least now the caller doesn't have to be aware of this.
2012-02-20 01:26:29 +01:00
GMimeSignatureList *siglist = node->sig_list;
show: Convert format_part_sigstatus_json to use sprinter
2012-08-03 03:14:54 +02:00
sp->begin_list (sp);
Add compatibility with gmime 2.6 There are lots of API changes in gmime 2.6 crypto handling. By adding preprocessor directives, it is however possible to add gmime 2.6 compatibility while preserving compatibility with gmime 2.4 too. This is mostly based on id:"8762i8hrb9.fsf@bookbinder.fernseed.info". This was tested against both gmime 2.6.4 and 2.4.31. With gmime 2.4.31, the crypto tests all work fine (as expected). With gmime 2.6.4, one crypto test is currently broken (signature verification with signer key unavailable), most likely because of a bug in gmime which will hopefully be fixed in a future version.
2012-01-20 10:39:24 +01:00
if (!siglist) {
show: Convert format_part_sigstatus_json to use sprinter
2012-08-03 03:14:54 +02:00
sp->end (sp);
Add compatibility with gmime 2.6 There are lots of API changes in gmime 2.6 crypto handling. By adding preprocessor directives, it is however possible to add gmime 2.6 compatibility while preserving compatibility with gmime 2.4 too. This is mostly based on id:"8762i8hrb9.fsf@bookbinder.fernseed.info". This was tested against both gmime 2.6.4 and 2.4.31. With gmime 2.4.31, the crypto tests all work fine (as expected). With gmime 2.6.4, one crypto test is currently broken (signature verification with signer key unavailable), most likely because of a bug in gmime which will hopefully be fixed in a future version.
2012-01-20 10:39:24 +01:00
return;
}
int i;
for (i = 0; i < g_mime_signature_list_length (siglist); i++) {
GMimeSignature *signature = g_mime_signature_list_get_signature (siglist, i);
show: Convert format_part_sigstatus_json to use sprinter
2012-08-03 03:14:54 +02:00
sp->begin_map (sp);
Add compatibility with gmime 2.6 There are lots of API changes in gmime 2.6 crypto handling. By adding preprocessor directives, it is however possible to add gmime 2.6 compatibility while preserving compatibility with gmime 2.4 too. This is mostly based on id:"8762i8hrb9.fsf@bookbinder.fernseed.info". This was tested against both gmime 2.6.4 and 2.4.31. With gmime 2.4.31, the crypto tests all work fine (as expected). With gmime 2.6.4, one crypto test is currently broken (signature verification with signer key unavailable), most likely because of a bug in gmime which will hopefully be fixed in a future version.
2012-01-20 10:39:24 +01:00
/* status */
GMimeSignatureStatus status = g_mime_signature_get_status (signature);
show: Convert format_part_sigstatus_json to use sprinter
2012-08-03 03:14:54 +02:00
sp->map_key (sp, "status");
sp->string (sp, signature_status_to_string (status));
Add compatibility with gmime 2.6 There are lots of API changes in gmime 2.6 crypto handling. By adding preprocessor directives, it is however possible to add gmime 2.6 compatibility while preserving compatibility with gmime 2.4 too. This is mostly based on id:"8762i8hrb9.fsf@bookbinder.fernseed.info". This was tested against both gmime 2.6.4 and 2.4.31. With gmime 2.4.31, the crypto tests all work fine (as expected). With gmime 2.6.4, one crypto test is currently broken (signature verification with signer key unavailable), most likely because of a bug in gmime which will hopefully be fixed in a future version.
2012-01-20 10:39:24 +01:00
GMimeCertificate *certificate = g_mime_signature_get_certificate (signature);
if (status == GMIME_SIGNATURE_STATUS_GOOD) {
show: Convert format_part_sigstatus_json to use sprinter
2012-08-03 03:14:54 +02:00
if (certificate) {
sp->map_key (sp, "fingerprint");
sp->string (sp, g_mime_certificate_get_fingerprint (certificate));
}
Add compatibility with gmime 2.6 There are lots of API changes in gmime 2.6 crypto handling. By adding preprocessor directives, it is however possible to add gmime 2.6 compatibility while preserving compatibility with gmime 2.4 too. This is mostly based on id:"8762i8hrb9.fsf@bookbinder.fernseed.info". This was tested against both gmime 2.6.4 and 2.4.31. With gmime 2.4.31, the crypto tests all work fine (as expected). With gmime 2.6.4, one crypto test is currently broken (signature verification with signer key unavailable), most likely because of a bug in gmime which will hopefully be fixed in a future version.
2012-01-20 10:39:24 +01:00
/* these dates are seconds since the epoch; should we
* provide a more human-readable format string? */
time_t created = g_mime_signature_get_created (signature);
show: Convert format_part_sigstatus_json to use sprinter
2012-08-03 03:14:54 +02:00
if (created != -1) {
sp->map_key (sp, "created");
sp->integer (sp, created);
}
Add compatibility with gmime 2.6 There are lots of API changes in gmime 2.6 crypto handling. By adding preprocessor directives, it is however possible to add gmime 2.6 compatibility while preserving compatibility with gmime 2.4 too. This is mostly based on id:"8762i8hrb9.fsf@bookbinder.fernseed.info". This was tested against both gmime 2.6.4 and 2.4.31. With gmime 2.4.31, the crypto tests all work fine (as expected). With gmime 2.6.4, one crypto test is currently broken (signature verification with signer key unavailable), most likely because of a bug in gmime which will hopefully be fixed in a future version.
2012-01-20 10:39:24 +01:00
time_t expires = g_mime_signature_get_expires (signature);
show: Convert format_part_sigstatus_json to use sprinter
2012-08-03 03:14:54 +02:00
if (expires > 0) {
sp->map_key (sp, "expires");
sp->integer (sp, expires);
}
Add compatibility with gmime 2.6 There are lots of API changes in gmime 2.6 crypto handling. By adding preprocessor directives, it is however possible to add gmime 2.6 compatibility while preserving compatibility with gmime 2.4 too. This is mostly based on id:"8762i8hrb9.fsf@bookbinder.fernseed.info". This was tested against both gmime 2.6.4 and 2.4.31. With gmime 2.4.31, the crypto tests all work fine (as expected). With gmime 2.6.4, one crypto test is currently broken (signature verification with signer key unavailable), most likely because of a bug in gmime which will hopefully be fixed in a future version.
2012-01-20 10:39:24 +01:00
/* output user id only if validity is FULL or ULTIMATE. */
/* note that gmime is using the term "trust" here, which
* is WRONG. It's actually user id "validity". */
if (certificate) {
const char *name = g_mime_certificate_get_name (certificate);
GMimeCertificateTrust trust = g_mime_certificate_get_trust (certificate);
show: Convert format_part_sigstatus_json to use sprinter
2012-08-03 03:14:54 +02:00
if (name && (trust == GMIME_CERTIFICATE_TRUST_FULLY || trust == GMIME_CERTIFICATE_TRUST_ULTIMATE)) {
sp->map_key (sp, "userid");
sp->string (sp, name);
}
Add compatibility with gmime 2.6 There are lots of API changes in gmime 2.6 crypto handling. By adding preprocessor directives, it is however possible to add gmime 2.6 compatibility while preserving compatibility with gmime 2.4 too. This is mostly based on id:"8762i8hrb9.fsf@bookbinder.fernseed.info". This was tested against both gmime 2.6.4 and 2.4.31. With gmime 2.4.31, the crypto tests all work fine (as expected). With gmime 2.6.4, one crypto test is currently broken (signature verification with signer key unavailable), most likely because of a bug in gmime which will hopefully be fixed in a future version.
2012-01-20 10:39:24 +01:00
}
} else if (certificate) {
const char *key_id = g_mime_certificate_get_key_id (certificate);
show: Convert format_part_sigstatus_json to use sprinter
2012-08-03 03:14:54 +02:00
if (key_id) {
sp->map_key (sp, "keyid");
sp->string (sp, key_id);
}
Add compatibility with gmime 2.6 There are lots of API changes in gmime 2.6 crypto handling. By adding preprocessor directives, it is however possible to add gmime 2.6 compatibility while preserving compatibility with gmime 2.4 too. This is mostly based on id:"8762i8hrb9.fsf@bookbinder.fernseed.info". This was tested against both gmime 2.6.4 and 2.4.31. With gmime 2.4.31, the crypto tests all work fine (as expected). With gmime 2.6.4, one crypto test is currently broken (signature verification with signer key unavailable), most likely because of a bug in gmime which will hopefully be fixed in a future version.
2012-01-20 10:39:24 +01:00
}
GMimeSignatureError errors = g_mime_signature_get_errors (signature);
if (errors != GMIME_SIGNATURE_ERROR_NONE) {
show: Convert format_part_sigstatus_json to use sprinter
2012-08-03 03:14:54 +02:00
sp->map_key (sp, "errors");
sp->integer (sp, errors);
Add compatibility with gmime 2.6 There are lots of API changes in gmime 2.6 crypto handling. By adding preprocessor directives, it is however possible to add gmime 2.6 compatibility while preserving compatibility with gmime 2.4 too. This is mostly based on id:"8762i8hrb9.fsf@bookbinder.fernseed.info". This was tested against both gmime 2.6.4 and 2.4.31. With gmime 2.4.31, the crypto tests all work fine (as expected). With gmime 2.6.4, one crypto test is currently broken (signature verification with signer key unavailable), most likely because of a bug in gmime which will hopefully be fixed in a future version.
2012-01-20 10:39:24 +01:00
}
show: Convert format_part_sigstatus_json to use sprinter
2012-08-03 03:14:54 +02:00
sp->end (sp);
Add compatibility with gmime 2.6 There are lots of API changes in gmime 2.6 crypto handling. By adding preprocessor directives, it is however possible to add gmime 2.6 compatibility while preserving compatibility with gmime 2.4 too. This is mostly based on id:"8762i8hrb9.fsf@bookbinder.fernseed.info". This was tested against both gmime 2.6.4 and 2.4.31. With gmime 2.4.31, the crypto tests all work fine (as expected). With gmime 2.6.4, one crypto test is currently broken (signature verification with signer key unavailable), most likely because of a bug in gmime which will hopefully be fixed in a future version.
2012-01-20 10:39:24 +01:00
}
show: Convert format_part_sigstatus_json to use sprinter
2012-08-03 03:14:54 +02:00
sp->end (sp);
Add compatibility with gmime 2.6 There are lots of API changes in gmime 2.6 crypto handling. By adding preprocessor directives, it is however possible to add gmime 2.6 compatibility while preserving compatibility with gmime 2.4 too. This is mostly based on id:"8762i8hrb9.fsf@bookbinder.fernseed.info". This was tested against both gmime 2.6.4 and 2.4.31. With gmime 2.4.31, the crypto tests all work fine (as expected). With gmime 2.6.4, one crypto test is currently broken (signature verification with signer key unavailable), most likely because of a bug in gmime which will hopefully be fixed in a future version.
2012-01-20 10:39:24 +01:00
}
cli: conform to same conditional build style as elsewhere in notmuch-show Conform to the same style for #ifdef GMIME_ATLEAST_26 conditional builds as elsewhere. There are no functional changes.
2013-03-30 14:53:17 +01:00
show: Allow formatters to return errors Formatter errors are propagated to the exit status of notmuch show. This isn't used by the JSON or text formatters, but it will be useful for the raw format, which is pickier.
2012-03-06 19:48:39 +01:00
static notmuch_status_t
show: Feed the sprinter down to part formatters There are several levels of function calls between where we create the sprinter and the call to the part formatter in show_message. This feeds the sprinter through all of them and into the part formatters.
2012-08-03 03:14:52 +02:00
format_part_text (const void *ctx, sprinter_t *sp, mime_node_t *node,
show: Convert text format to the new self-recursive style This is all code movement and a smidgen of glue. This moves the existing text formatter code into one self-recursive function, but doesn't change any of the logic. The next patch will actually take advantage of what the new structure has to offer. Note that this patch retains format_headers_message_part_text because it is also used by the raw format.
2012-02-04 22:24:25 +01:00
int indent, const notmuch_show_params_t *params)
{
/* The disposition and content-type metadata are associated with
* the envelope for message parts */
GMimeObject *meta = node->envelope_part ?
GMIME_OBJECT (node->envelope_part) : node->part;
GMimeContentType *content_type = g_mime_object_get_content_type (meta);
show: Simplify new text formatter code This makes the text formatter take advantage of the new code structure. The previously duplicated header logic is now unified, several things that we used to compute repeatedly across different callbacks are now computed once, and the code is simpler overall and 32% shorter. Unifying the header logic causes this to format some dates slightly differently, so the two affected test cases are updated.
2012-02-04 22:24:26 +01:00
const notmuch_bool_t leaf = GMIME_IS_PART (node->part);
const char *part_type;
show: Convert text format to the new self-recursive style This is all code movement and a smidgen of glue. This moves the existing text formatter code into one self-recursive function, but doesn't change any of the logic. The next patch will actually take advantage of what the new structure has to offer. Note that this patch retains format_headers_message_part_text because it is also used by the raw format.
2012-02-04 22:24:25 +01:00
int i;
if (node->envelope_file) {
notmuch_message_t *message = node->envelope_file;
show: Simplify new text formatter code This makes the text formatter take advantage of the new code structure. The previously duplicated header logic is now unified, several things that we used to compute repeatedly across different callbacks are now computed once, and the code is simpler overall and 32% shorter. Unifying the header logic causes this to format some dates slightly differently, so the two affected test cases are updated.
2012-02-04 22:24:26 +01:00
part_type = "message";
cli: Make notmuch-show respect excludes. This adds the excludes to notmuch-show.c. We do not exclude when only a single message (or part) is requested. notmuch-show will output the exclude information when either text or json format is requested. As this changes the output from notmuch-show it breaks many tests (in a trivial and expected fashion).
2012-03-01 23:30:40 +01:00
printf ("\f%s{ id:%s depth:%d match:%d excluded:%d filename:%s\n",
show: Simplify new text formatter code This makes the text formatter take advantage of the new code structure. The previously duplicated header logic is now unified, several things that we used to compute repeatedly across different callbacks are now computed once, and the code is simpler overall and 32% shorter. Unifying the header logic causes this to format some dates slightly differently, so the two affected test cases are updated.
2012-02-04 22:24:26 +01:00
part_type,
show: Convert text format to the new self-recursive style This is all code movement and a smidgen of glue. This moves the existing text formatter code into one self-recursive function, but doesn't change any of the logic. The next patch will actually take advantage of what the new structure has to offer. Note that this patch retains format_headers_message_part_text because it is also used by the raw format.
2012-02-04 22:24:25 +01:00
notmuch_message_get_message_id (message),
indent,
cli: Make notmuch-show respect excludes. This adds the excludes to notmuch-show.c. We do not exclude when only a single message (or part) is requested. notmuch-show will output the exclude information when either text or json format is requested. As this changes the output from notmuch-show it breaks many tests (in a trivial and expected fashion).
2012-03-01 23:30:40 +01:00
notmuch_message_get_flag (message, NOTMUCH_MESSAGE_FLAG_MATCH) ? 1 : 0,
notmuch_message_get_flag (message, NOTMUCH_MESSAGE_FLAG_EXCLUDED) ? 1 : 0,
show: Convert text format to the new self-recursive style This is all code movement and a smidgen of glue. This moves the existing text formatter code into one self-recursive function, but doesn't change any of the logic. The next patch will actually take advantage of what the new structure has to offer. Note that this patch retains format_headers_message_part_text because it is also used by the raw format.
2012-02-04 22:24:25 +01:00
notmuch_message_get_filename (message));
} else {
cli/show: fix usage of g_mime_content_type_to_string It returns an "allocated string", which needs to be freed.
2017-03-18 18:33:50 +01:00
char *content_string;
cli/show: abstract get content disposition Reduce duplication in follow-up work. As a side effect, handle error returns from g_mime_content_disposition_get_disposition() without segfaulting.
2017-02-26 19:33:47 +01:00
const char *disposition = _get_disposition (meta);
show: Convert text format to the new self-recursive style This is all code movement and a smidgen of glue. This moves the existing text formatter code into one self-recursive function, but doesn't change any of the logic. The next patch will actually take advantage of what the new structure has to offer. Note that this patch retains format_headers_message_part_text because it is also used by the raw format.
2012-02-04 22:24:25 +01:00
const char *cid = g_mime_object_get_content_id (meta);
show: Simplify new text formatter code This makes the text formatter take advantage of the new code structure. The previously duplicated header logic is now unified, several things that we used to compute repeatedly across different callbacks are now computed once, and the code is simpler overall and 32% shorter. Unifying the header logic causes this to format some dates slightly differently, so the two affected test cases are updated.
2012-02-04 22:24:26 +01:00
const char *filename = leaf ?
g_mime_part_get_filename (GMIME_PART (node->part)) : NULL;
show: Convert text format to the new self-recursive style This is all code movement and a smidgen of glue. This moves the existing text formatter code into one self-recursive function, but doesn't change any of the logic. The next patch will actually take advantage of what the new structure has to offer. Note that this patch retains format_headers_message_part_text because it is also used by the raw format.
2012-02-04 22:24:25 +01:00
if (disposition &&
cli/show: abstract get content disposition Reduce duplication in follow-up work. As a side effect, handle error returns from g_mime_content_disposition_get_disposition() without segfaulting.
2017-02-26 19:33:47 +01:00
strcasecmp (disposition, GMIME_DISPOSITION_ATTACHMENT) == 0)
show: Simplify new text formatter code This makes the text formatter take advantage of the new code structure. The previously duplicated header logic is now unified, several things that we used to compute repeatedly across different callbacks are now computed once, and the code is simpler overall and 32% shorter. Unifying the header logic causes this to format some dates slightly differently, so the two affected test cases are updated.
2012-02-04 22:24:26 +01:00
part_type = "attachment";
else
part_type = "part";
show: Convert text format to the new self-recursive style This is all code movement and a smidgen of glue. This moves the existing text formatter code into one self-recursive function, but doesn't change any of the logic. The next patch will actually take advantage of what the new structure has to offer. Note that this patch retains format_headers_message_part_text because it is also used by the raw format.
2012-02-04 22:24:25 +01:00
show: Simplify new text formatter code This makes the text formatter take advantage of the new code structure. The previously duplicated header logic is now unified, several things that we used to compute repeatedly across different callbacks are now computed once, and the code is simpler overall and 32% shorter. Unifying the header logic causes this to format some dates slightly differently, so the two affected test cases are updated.
2012-02-04 22:24:26 +01:00
printf ("\f%s{ ID: %d", part_type, node->part_num);
if (filename)
printf (", Filename: %s", filename);
show: Convert text format to the new self-recursive style This is all code movement and a smidgen of glue. This moves the existing text formatter code into one self-recursive function, but doesn't change any of the logic. The next patch will actually take advantage of what the new structure has to offer. Note that this patch retains format_headers_message_part_text because it is also used by the raw format.
2012-02-04 22:24:25 +01:00
if (cid)
printf (", Content-id: %s", cid);
cli/show: fix usage of g_mime_content_type_to_string It returns an "allocated string", which needs to be freed.
2017-03-18 18:33:50 +01:00
content_string = g_mime_content_type_to_string (content_type);
printf (", Content-type: %s\n", content_string);
g_free (content_string);
show: Convert text format to the new self-recursive style This is all code movement and a smidgen of glue. This moves the existing text formatter code into one self-recursive function, but doesn't change any of the logic. The next patch will actually take advantage of what the new structure has to offer. Note that this patch retains format_headers_message_part_text because it is also used by the raw format.
2012-02-04 22:24:25 +01:00
}
show: Simplify new text formatter code This makes the text formatter take advantage of the new code structure. The previously duplicated header logic is now unified, several things that we used to compute repeatedly across different callbacks are now computed once, and the code is simpler overall and 32% shorter. Unifying the header logic causes this to format some dates slightly differently, so the two affected test cases are updated.
2012-02-04 22:24:26 +01:00
if (GMIME_IS_MESSAGE (node->part)) {
show: Convert text format to the new self-recursive style This is all code movement and a smidgen of glue. This moves the existing text formatter code into one self-recursive function, but doesn't change any of the logic. The next patch will actually take advantage of what the new structure has to offer. Note that this patch retains format_headers_message_part_text because it is also used by the raw format.
2012-02-04 22:24:25 +01:00
GMimeMessage *message = GMIME_MESSAGE (node->part);
InternetAddressList *recipients;
cli/show: fix some memory leaks in format_part_text Mimic Jeff Stedfast's changes to format_headers_sprinter, clean up use of internet_address_list_to_string and g_mime_message_get_date_as_string.
2017-03-18 18:07:45 +01:00
char *recipients_string;
char *date_string;
show: Convert text format to the new self-recursive style This is all code movement and a smidgen of glue. This moves the existing text formatter code into one self-recursive function, but doesn't change any of the logic. The next patch will actually take advantage of what the new structure has to offer. Note that this patch retains format_headers_message_part_text because it is also used by the raw format.
2012-02-04 22:24:25 +01:00
printf ("\fheader{\n");
show: Simplify new text formatter code This makes the text formatter take advantage of the new code structure. The previously duplicated header logic is now unified, several things that we used to compute repeatedly across different callbacks are now computed once, and the code is simpler overall and 32% shorter. Unifying the header logic causes this to format some dates slightly differently, so the two affected test cases are updated.
2012-02-04 22:24:26 +01:00
if (node->envelope_file)
printf ("%s\n", _get_one_line_summary (ctx, node->envelope_file));
show: Convert text format to the new self-recursive style This is all code movement and a smidgen of glue. This moves the existing text formatter code into one self-recursive function, but doesn't change any of the logic. The next patch will actually take advantage of what the new structure has to offer. Note that this patch retains format_headers_message_part_text because it is also used by the raw format.
2012-02-04 22:24:25 +01:00
printf ("Subject: %s\n", g_mime_message_get_subject (message));
printf ("From: %s\n", g_mime_message_get_sender (message));
recipients = g_mime_message_get_recipients (message, GMIME_RECIPIENT_TYPE_TO);
recipients_string = internet_address_list_to_string (recipients, 0);
if (recipients_string)
printf ("To: %s\n", recipients_string);
cli/show: fix some memory leaks in format_part_text Mimic Jeff Stedfast's changes to format_headers_sprinter, clean up use of internet_address_list_to_string and g_mime_message_get_date_as_string.
2017-03-18 18:07:45 +01:00
g_free (recipients_string);
show: Convert text format to the new self-recursive style This is all code movement and a smidgen of glue. This moves the existing text formatter code into one self-recursive function, but doesn't change any of the logic. The next patch will actually take advantage of what the new structure has to offer. Note that this patch retains format_headers_message_part_text because it is also used by the raw format.
2012-02-04 22:24:25 +01:00
recipients = g_mime_message_get_recipients (message, GMIME_RECIPIENT_TYPE_CC);
recipients_string = internet_address_list_to_string (recipients, 0);
if (recipients_string)
printf ("Cc: %s\n", recipients_string);
cli/show: fix some memory leaks in format_part_text Mimic Jeff Stedfast's changes to format_headers_sprinter, clean up use of internet_address_list_to_string and g_mime_message_get_date_as_string.
2017-03-18 18:07:45 +01:00
g_free (recipients_string);
date_string = g_mime_message_get_date_as_string (message);
printf ("Date: %s\n", date_string);
g_free (date_string);
show: Convert text format to the new self-recursive style This is all code movement and a smidgen of glue. This moves the existing text formatter code into one self-recursive function, but doesn't change any of the logic. The next patch will actually take advantage of what the new structure has to offer. Note that this patch retains format_headers_message_part_text because it is also used by the raw format.
2012-02-04 22:24:25 +01:00
printf ("\fheader}\n");
show: Simplify new text formatter code This makes the text formatter take advantage of the new code structure. The previously duplicated header logic is now unified, several things that we used to compute repeatedly across different callbacks are now computed once, and the code is simpler overall and 32% shorter. Unifying the header logic causes this to format some dates slightly differently, so the two affected test cases are updated.
2012-02-04 22:24:26 +01:00
printf ("\fbody{\n");
show: Convert text format to the new self-recursive style This is all code movement and a smidgen of glue. This moves the existing text formatter code into one self-recursive function, but doesn't change any of the logic. The next patch will actually take advantage of what the new structure has to offer. Note that this patch retains format_headers_message_part_text because it is also used by the raw format.
2012-02-04 22:24:25 +01:00
}
show: Simplify new text formatter code This makes the text formatter take advantage of the new code structure. The previously duplicated header logic is now unified, several things that we used to compute repeatedly across different callbacks are now computed once, and the code is simpler overall and 32% shorter. Unifying the header logic causes this to format some dates slightly differently, so the two affected test cases are updated.
2012-02-04 22:24:26 +01:00
if (leaf) {
show: Convert text format to the new self-recursive style This is all code movement and a smidgen of glue. This moves the existing text formatter code into one self-recursive function, but doesn't change any of the logic. The next patch will actually take advantage of what the new structure has to offer. Note that this patch retains format_headers_message_part_text because it is also used by the raw format.
2012-02-04 22:24:25 +01:00
if (g_mime_content_type_is_type (content_type, "text", "*") &&
!g_mime_content_type_is_type (content_type, "text", "html"))
{
GMimeStream *stream_stdout = g_mime_stream_file_new (stdout);
g_mime_stream_file_set_owner (GMIME_STREAM_FILE (stream_stdout), FALSE);
show/reply: Unify the code that extracts text parts Previously, show and reply had separate implementations of decoding and printing text parts. Now both use show's implementation, which was more complete. Show's implementation has been extended with an option to add reply quoting to the extracted part (this is implemented as a named flag to avoid naked booleans, even though it's the only flag it can take).
2012-03-27 23:59:50 +02:00
show_text_part_content (node->part, stream_stdout, 0);
show: Convert text format to the new self-recursive style This is all code movement and a smidgen of glue. This moves the existing text formatter code into one self-recursive function, but doesn't change any of the logic. The next patch will actually take advantage of what the new structure has to offer. Note that this patch retains format_headers_message_part_text because it is also used by the raw format.
2012-02-04 22:24:25 +01:00
g_object_unref(stream_stdout);
show: Simplify new text formatter code This makes the text formatter take advantage of the new code structure. The previously duplicated header logic is now unified, several things that we used to compute repeatedly across different callbacks are now computed once, and the code is simpler overall and 32% shorter. Unifying the header logic causes this to format some dates slightly differently, so the two affected test cases are updated.
2012-02-04 22:24:26 +01:00
} else {
cli/show: fix usage of g_mime_content_type_to_string It returns an "allocated string", which needs to be freed.
2017-03-18 18:33:50 +01:00
char *content_string = g_mime_content_type_to_string (content_type);
printf ("Non-text part: %s\n", content_string);
g_free (content_string);
show: Convert text format to the new self-recursive style This is all code movement and a smidgen of glue. This moves the existing text formatter code into one self-recursive function, but doesn't change any of the logic. The next patch will actually take advantage of what the new structure has to offer. Note that this patch retains format_headers_message_part_text because it is also used by the raw format.
2012-02-04 22:24:25 +01:00
}
}
for (i = 0; i < node->nchildren; i++)
show: Feed the sprinter down to part formatters There are several levels of function calls between where we create the sprinter and the call to the part formatter in show_message. This feeds the sprinter through all of them and into the part formatters.
2012-08-03 03:14:52 +02:00
format_part_text (ctx, sp, mime_node_child (node, i), indent, params);
show: Convert text format to the new self-recursive style This is all code movement and a smidgen of glue. This moves the existing text formatter code into one self-recursive function, but doesn't change any of the logic. The next patch will actually take advantage of what the new structure has to offer. Note that this patch retains format_headers_message_part_text because it is also used by the raw format.
2012-02-04 22:24:25 +01:00
if (GMIME_IS_MESSAGE (node->part))
printf ("\fbody}\n");
show: Simplify new text formatter code This makes the text formatter take advantage of the new code structure. The previously duplicated header logic is now unified, several things that we used to compute repeatedly across different callbacks are now computed once, and the code is simpler overall and 32% shorter. Unifying the header logic causes this to format some dates slightly differently, so the two affected test cases are updated.
2012-02-04 22:24:26 +01:00
printf ("\f%s}\n", part_type);
show: Allow formatters to return errors Formatter errors are propagated to the exit status of notmuch show. This isn't used by the JSON or text formatters, but it will be useful for the raw format, which is pickier.
2012-03-06 19:48:39 +01:00
return NOTMUCH_STATUS_SUCCESS;
show: Convert text format to the new self-recursive style This is all code movement and a smidgen of glue. This moves the existing text formatter code into one self-recursive function, but doesn't change any of the logic. The next patch will actually take advantage of what the new structure has to offer. Note that this patch retains format_headers_message_part_text because it is also used by the raw format.
2012-02-04 22:24:25 +01:00
}
show: indicate charset for all omitted parts Write a "charset" field for all omitted parts for which it is applicable, not only text/html parts. Factor out the code to a separate function. It will be extended with more fields next.
2012-12-16 00:22:50 +01:00
static void
show: indicate length, encoding of omitted body content If a leaf part's body content is omitted, return the encoded length and transfer encoding in --format=json output. This information may be used by the consumer, e.g. to decide whether to download a large attachment over a slow link. Returning the _encoded_ content length is more efficient than returning the _decoded_ content length. Returning the transfer encoding allows the consumer to estimate the decoded content length.
2012-12-16 00:24:23 +01:00
format_omitted_part_meta_sprinter (sprinter_t *sp, GMimeObject *meta, GMimePart *part)
show: indicate charset for all omitted parts Write a "charset" field for all omitted parts for which it is applicable, not only text/html parts. Factor out the code to a separate function. It will be extended with more fields next.
2012-12-16 00:22:50 +01:00
{
const char *content_charset = g_mime_object_get_content_type_parameter (meta, "charset");
show: indicate length, encoding of omitted body content If a leaf part's body content is omitted, return the encoded length and transfer encoding in --format=json output. This information may be used by the consumer, e.g. to decide whether to download a large attachment over a slow link. Returning the _encoded_ content length is more efficient than returning the _decoded_ content length. Returning the transfer encoding allows the consumer to estimate the decoded content length.
2012-12-16 00:24:23 +01:00
const char *cte = g_mime_object_get_header (meta, "content-transfer-encoding");
GMimeDataWrapper *wrapper = g_mime_part_get_content_object (part);
GMimeStream *stream = g_mime_data_wrapper_get_stream (wrapper);
ssize_t content_length = g_mime_stream_length (stream);
show: indicate charset for all omitted parts Write a "charset" field for all omitted parts for which it is applicable, not only text/html parts. Factor out the code to a separate function. It will be extended with more fields next.
2012-12-16 00:22:50 +01:00
if (content_charset != NULL) {
sp->map_key (sp, "content-charset");
sp->string (sp, content_charset);
}
show: indicate length, encoding of omitted body content If a leaf part's body content is omitted, return the encoded length and transfer encoding in --format=json output. This information may be used by the consumer, e.g. to decide whether to download a large attachment over a slow link. Returning the _encoded_ content length is more efficient than returning the _decoded_ content length. Returning the transfer encoding allows the consumer to estimate the decoded content length.
2012-12-16 00:24:23 +01:00
if (cte != NULL) {
sp->map_key (sp, "content-transfer-encoding");
sp->string (sp, cte);
}
if (content_length >= 0) {
sp->map_key (sp, "content-length");
sp->integer (sp, content_length);
}
show: indicate charset for all omitted parts Write a "charset" field for all omitted parts for which it is applicable, not only text/html parts. Factor out the code to a separate function. It will be extended with more fields next.
2012-12-16 00:22:50 +01:00
}
reply: Add a JSON reply format. This new JSON format for replies includes headers generated for a reply message as well as the headers of the original message. Using this data, a client can intelligently create a reply. For example, the emacs client will be able to create replies with quoted HTML parts by parsing the HTML parts.
2012-03-18 17:32:36 +01:00
void
Rename the -json printer functions in notmuch-reply and notmuch-show to generic -sprinter functions. All the structured output functions in notmuch-reply and notmuch-show are renamed to a generic name (as they do not contain any json-specific code anyway). This patch is a preparation to actually using the new S-Expression sprinter in notmuch-reply and notmuch-show.
2012-12-06 22:12:12 +01:00
format_part_sprinter (const void *ctx, sprinter_t *sp, mime_node_t *node,
cli: add --include-html option to notmuch show For my client, the largest bottleneck for displaying large threads is exporting each html part individually since by default notmuch will not show the json parts. For large threads there can be quite a few parts and each must be exported and decoded one by one. Also, I then have to deal with all the crazy charsets which I can do through a library but is a pain. Therefore, this patch adds an --include-html option that causes the text/html parts to be included as part of the output of show. diff man/man1/notmuch-show.1
2013-07-02 02:19:42 +02:00
notmuch_bool_t first, notmuch_bool_t output_body,
notmuch_bool_t include_html)
show: Convert JSON format to the new self-recursive style As before, this is all code movement and a smidgen of glue. This moves the existing JSON formatter code into one self-recursive function, but doesn't change any of the logic to take advantage of the new structure. In general, "leafs" of the JSON structure are left in helper functions (most of them untouched), so that it's easy to see the overall structure of the format from the main recursive function.
2012-02-20 01:26:24 +01:00
{
Use the S-Expression structured printer in notmuch-show, notmuch-reply and notmuch-search. This patch uses the new S-Expression printer in the notmuch CLI (show, search and reply). You can now use --format=sexp for any of them.
2012-12-06 22:12:13 +01:00
/* Any changes to the JSON or S-Expression format should be
* reflected in the file devel/schemata. */
show: Convert JSON format to the new self-recursive style As before, this is all code movement and a smidgen of glue. This moves the existing JSON formatter code into one self-recursive function, but doesn't change any of the logic to take advantage of the new structure. In general, "leafs" of the JSON structure are left in helper functions (most of them untouched), so that it's easy to see the overall structure of the format from the main recursive function.
2012-02-20 01:26:24 +01:00
if (node->envelope_file) {
show: Convert envelope format_part_json to use sprinter
2012-08-03 03:14:56 +02:00
sp->begin_map (sp);
Rename the -json printer functions in notmuch-reply and notmuch-show to generic -sprinter functions. All the structured output functions in notmuch-reply and notmuch-show are renamed to a generic name (as they do not contain any json-specific code anyway). This patch is a preparation to actually using the new S-Expression sprinter in notmuch-reply and notmuch-show.
2012-12-06 22:12:12 +01:00
format_message_sprinter (sp, node->envelope_file);
show: Convert JSON format to the new self-recursive style As before, this is all code movement and a smidgen of glue. This moves the existing JSON formatter code into one self-recursive function, but doesn't change any of the logic to take advantage of the new structure. In general, "leafs" of the JSON structure are left in helper functions (most of them untouched), so that it's easy to see the overall structure of the format from the main recursive function.
2012-02-20 01:26:24 +01:00
show: Convert envelope format_part_json to use sprinter
2012-08-03 03:14:56 +02:00
sp->map_key (sp, "headers");
Rename the -json printer functions in notmuch-reply and notmuch-show to generic -sprinter functions. All the structured output functions in notmuch-reply and notmuch-show are renamed to a generic name (as they do not contain any json-specific code anyway). This patch is a preparation to actually using the new S-Expression sprinter in notmuch-reply and notmuch-show.
2012-12-06 22:12:12 +01:00
format_headers_sprinter (sp, GMIME_MESSAGE (node->part), FALSE);
show: Convert JSON format to the new self-recursive style As before, this is all code movement and a smidgen of glue. This moves the existing JSON formatter code into one self-recursive function, but doesn't change any of the logic to take advantage of the new structure. In general, "leafs" of the JSON structure are left in helper functions (most of them untouched), so that it's easy to see the overall structure of the format from the main recursive function.
2012-02-20 01:26:24 +01:00
cli: add --body=true|false option to notmuch-show.c This option allows the caller to suppress the output of the bodies of the messages. Currently this is only implemented for format=json. This is used by notmuch-pick.el (although not needed) because it gives a speed-up of at least a factor of a two (and in some cases a speed up of more than a factor of 8); moreover it reduces the memory usage in emacs hugely.
2012-07-24 20:23:27 +02:00
if (output_body) {
show: Convert envelope format_part_json to use sprinter
2012-08-03 03:14:56 +02:00
sp->map_key (sp, "body");
sp->begin_list (sp);
cli: add --include-html option to notmuch show For my client, the largest bottleneck for displaying large threads is exporting each html part individually since by default notmuch will not show the json parts. For large threads there can be quite a few parts and each must be exported and decoded one by one. Also, I then have to deal with all the crazy charsets which I can do through a library but is a pain. Therefore, this patch adds an --include-html option that causes the text/html parts to be included as part of the output of show. diff man/man1/notmuch-show.1
2013-07-02 02:19:42 +02:00
format_part_sprinter (ctx, sp, mime_node_child (node, 0), first, TRUE, include_html);
show: Convert envelope format_part_json to use sprinter
2012-08-03 03:14:56 +02:00
sp->end (sp);
cli: add --body=true|false option to notmuch-show.c This option allows the caller to suppress the output of the bodies of the messages. Currently this is only implemented for format=json. This is used by notmuch-pick.el (although not needed) because it gives a speed-up of at least a factor of a two (and in some cases a speed up of more than a factor of 8); moreover it reduces the memory usage in emacs hugely.
2012-07-24 20:23:27 +02:00
}
show: Convert envelope format_part_json to use sprinter
2012-08-03 03:14:56 +02:00
sp->end (sp);
show: Convert JSON format to the new self-recursive style As before, this is all code movement and a smidgen of glue. This moves the existing JSON formatter code into one self-recursive function, but doesn't change any of the logic to take advantage of the new structure. In general, "leafs" of the JSON structure are left in helper functions (most of them untouched), so that it's easy to see the overall structure of the format from the main recursive function.
2012-02-20 01:26:24 +01:00
return;
}
/* The disposition and content-type metadata are associated with
* the envelope for message parts */
GMimeObject *meta = node->envelope_part ?
GMIME_OBJECT (node->envelope_part) : node->part;
GMimeContentType *content_type = g_mime_object_get_content_type (meta);
cli/show: fix usage of g_mime_content_type_to_string It returns an "allocated string", which needs to be freed.
2017-03-18 18:33:50 +01:00
char *content_string;
cli/show: add content-disposition to structured output message parts Help the clients decide how to display parts. Test updates by Mark Walters <markwalters1009@gmail.com>. One more test fix by db
2017-02-26 19:33:48 +01:00
const char *disposition = _get_disposition (meta);
show: Convert JSON format to the new self-recursive style As before, this is all code movement and a smidgen of glue. This moves the existing JSON formatter code into one self-recursive function, but doesn't change any of the logic to take advantage of the new structure. In general, "leafs" of the JSON structure are left in helper functions (most of them untouched), so that it's easy to see the overall structure of the format from the main recursive function.
2012-02-20 01:26:24 +01:00
const char *cid = g_mime_object_get_content_id (meta);
show: Further general simplifications of the JSON formatter
2012-02-20 01:26:30 +01:00
const char *filename = GMIME_IS_PART (node->part) ?
g_mime_part_get_filename (GMIME_PART (node->part)) : NULL;
show: Convert non-envelope format_part_json to use sprinter
2012-08-03 03:14:55 +02:00
int nclose = 0;
show: Convert JSON format to the new self-recursive style As before, this is all code movement and a smidgen of glue. This moves the existing JSON formatter code into one self-recursive function, but doesn't change any of the logic to take advantage of the new structure. In general, "leafs" of the JSON structure are left in helper functions (most of them untouched), so that it's easy to see the overall structure of the format from the main recursive function.
2012-02-20 01:26:24 +01:00
int i;
show: Convert non-envelope format_part_json to use sprinter
2012-08-03 03:14:55 +02:00
sp->begin_map (sp);
show: Convert JSON format to the new self-recursive style As before, this is all code movement and a smidgen of glue. This moves the existing JSON formatter code into one self-recursive function, but doesn't change any of the logic to take advantage of the new structure. In general, "leafs" of the JSON structure are left in helper functions (most of them untouched), so that it's easy to see the overall structure of the format from the main recursive function.
2012-02-20 01:26:24 +01:00
show: Convert non-envelope format_part_json to use sprinter
2012-08-03 03:14:55 +02:00
sp->map_key (sp, "id");
sp->integer (sp, node->part_num);
show: Convert JSON format to the new self-recursive style As before, this is all code movement and a smidgen of glue. This moves the existing JSON formatter code into one self-recursive function, but doesn't change any of the logic to take advantage of the new structure. In general, "leafs" of the JSON structure are left in helper functions (most of them untouched), so that it's easy to see the overall structure of the format from the main recursive function.
2012-02-20 01:26:24 +01:00
show: Convert non-envelope format_part_json to use sprinter
2012-08-03 03:14:55 +02:00
if (node->decrypt_attempted) {
sp->map_key (sp, "encstatus");
sp->begin_list (sp);
sp->begin_map (sp);
sp->map_key (sp, "status");
sp->string (sp, node->decrypt_success ? "good" : "bad");
sp->end (sp);
sp->end (sp);
}
show: Convert JSON format to the new self-recursive style As before, this is all code movement and a smidgen of glue. This moves the existing JSON formatter code into one self-recursive function, but doesn't change any of the logic to take advantage of the new structure. In general, "leafs" of the JSON structure are left in helper functions (most of them untouched), so that it's easy to see the overall structure of the format from the main recursive function.
2012-02-20 01:26:24 +01:00
if (node->verify_attempted) {
show: Convert non-envelope format_part_json to use sprinter
2012-08-03 03:14:55 +02:00
sp->map_key (sp, "sigstatus");
Rename the -json printer functions in notmuch-reply and notmuch-show to generic -sprinter functions. All the structured output functions in notmuch-reply and notmuch-show are renamed to a generic name (as they do not contain any json-specific code anyway). This patch is a preparation to actually using the new S-Expression sprinter in notmuch-reply and notmuch-show.
2012-12-06 22:12:12 +01:00
format_part_sigstatus_sprinter (sp, node);
show: Convert JSON format to the new self-recursive style As before, this is all code movement and a smidgen of glue. This moves the existing JSON formatter code into one self-recursive function, but doesn't change any of the logic to take advantage of the new structure. In general, "leafs" of the JSON structure are left in helper functions (most of them untouched), so that it's easy to see the overall structure of the format from the main recursive function.
2012-02-20 01:26:24 +01:00
}
show: Convert non-envelope format_part_json to use sprinter
2012-08-03 03:14:55 +02:00
sp->map_key (sp, "content-type");
cli/show: fix usage of g_mime_content_type_to_string It returns an "allocated string", which needs to be freed.
2017-03-18 18:33:50 +01:00
content_string = g_mime_content_type_to_string (content_type);
sp->string (sp, content_string);
g_free (content_string);
show: Convert JSON format to the new self-recursive style As before, this is all code movement and a smidgen of glue. This moves the existing JSON formatter code into one self-recursive function, but doesn't change any of the logic to take advantage of the new structure. In general, "leafs" of the JSON structure are left in helper functions (most of them untouched), so that it's easy to see the overall structure of the format from the main recursive function.
2012-02-20 01:26:24 +01:00
cli/show: add content-disposition to structured output message parts Help the clients decide how to display parts. Test updates by Mark Walters <markwalters1009@gmail.com>. One more test fix by db
2017-02-26 19:33:48 +01:00
if (disposition) {
sp->map_key (sp, "content-disposition");
sp->string (sp, disposition);
}
show: Convert non-envelope format_part_json to use sprinter
2012-08-03 03:14:55 +02:00
if (cid) {
sp->map_key (sp, "content-id");
sp->string (sp, cid);
}
show: Convert JSON format to the new self-recursive style As before, this is all code movement and a smidgen of glue. This moves the existing JSON formatter code into one self-recursive function, but doesn't change any of the logic to take advantage of the new structure. In general, "leafs" of the JSON structure are left in helper functions (most of them untouched), so that it's easy to see the overall structure of the format from the main recursive function.
2012-02-20 01:26:24 +01:00
show: Convert non-envelope format_part_json to use sprinter
2012-08-03 03:14:55 +02:00
if (filename) {
sp->map_key (sp, "filename");
sp->string (sp, filename);
}
show: Convert JSON format to the new self-recursive style As before, this is all code movement and a smidgen of glue. This moves the existing JSON formatter code into one self-recursive function, but doesn't change any of the logic to take advantage of the new structure. In general, "leafs" of the JSON structure are left in helper functions (most of them untouched), so that it's easy to see the overall structure of the format from the main recursive function.
2012-02-20 01:26:24 +01:00
show: Further general simplifications of the JSON formatter
2012-02-20 01:26:30 +01:00
if (GMIME_IS_PART (node->part)) {
show: Convert JSON format to the new self-recursive style As before, this is all code movement and a smidgen of glue. This moves the existing JSON formatter code into one self-recursive function, but doesn't change any of the logic to take advantage of the new structure. In general, "leafs" of the JSON structure are left in helper functions (most of them untouched), so that it's easy to see the overall structure of the format from the main recursive function.
2012-02-20 01:26:24 +01:00
/* For non-HTML text parts, we include the content in the
* JSON. Since JSON must be Unicode, we handle charset
* decoding here and do not report a charset to the caller.
cli: add --include-html option to notmuch show For my client, the largest bottleneck for displaying large threads is exporting each html part individually since by default notmuch will not show the json parts. For large threads there can be quite a few parts and each must be exported and decoded one by one. Also, I then have to deal with all the crazy charsets which I can do through a library but is a pain. Therefore, this patch adds an --include-html option that causes the text/html parts to be included as part of the output of show. diff man/man1/notmuch-show.1
2013-07-02 02:19:42 +02:00
* For text/html parts, we do not include the content unless
* the --include-html option has been passed. If a html part
* is not included, it can be requested directly. This makes
* charset decoding the responsibility on the caller so we
show: Convert JSON format to the new self-recursive style As before, this is all code movement and a smidgen of glue. This moves the existing JSON formatter code into one self-recursive function, but doesn't change any of the logic to take advantage of the new structure. In general, "leafs" of the JSON structure are left in helper functions (most of them untouched), so that it's easy to see the overall structure of the format from the main recursive function.
2012-02-20 01:26:24 +01:00
* report the charset for text/html parts.
*/
show: indicate charset for all omitted parts Write a "charset" field for all omitted parts for which it is applicable, not only text/html parts. Factor out the code to a separate function. It will be extended with more fields next.
2012-12-16 00:22:50 +01:00
if (g_mime_content_type_is_type (content_type, "text", "*") &&
cli: add --include-html option to notmuch show For my client, the largest bottleneck for displaying large threads is exporting each html part individually since by default notmuch will not show the json parts. For large threads there can be quite a few parts and each must be exported and decoded one by one. Also, I then have to deal with all the crazy charsets which I can do through a library but is a pain. Therefore, this patch adds an --include-html option that causes the text/html parts to be included as part of the output of show. diff man/man1/notmuch-show.1
2013-07-02 02:19:42 +02:00
(include_html ||
! g_mime_content_type_is_type (content_type, "text", "html")))
show: indicate charset for all omitted parts Write a "charset" field for all omitted parts for which it is applicable, not only text/html parts. Factor out the code to a separate function. It will be extended with more fields next.
2012-12-16 00:22:50 +01:00
{
show: Further general simplifications of the JSON formatter
2012-02-20 01:26:30 +01:00
GMimeStream *stream_memory = g_mime_stream_mem_new ();
GByteArray *part_content;
show/reply: Unify the code that extracts text parts Previously, show and reply had separate implementations of decoding and printing text parts. Now both use show's implementation, which was more complete. Show's implementation has been extended with an option to add reply quoting to the extracted part (this is implemented as a named flag to avoid naked booleans, even though it's the only flag it can take).
2012-03-27 23:59:50 +02:00
show_text_part_content (node->part, stream_memory, 0);
show: Convert JSON format to the new self-recursive style As before, this is all code movement and a smidgen of glue. This moves the existing JSON formatter code into one self-recursive function, but doesn't change any of the logic to take advantage of the new structure. In general, "leafs" of the JSON structure are left in helper functions (most of them untouched), so that it's easy to see the overall structure of the format from the main recursive function.
2012-02-20 01:26:24 +01:00
part_content = g_mime_stream_mem_get_byte_array (GMIME_STREAM_MEM (stream_memory));
show: Convert non-envelope format_part_json to use sprinter
2012-08-03 03:14:55 +02:00
sp->map_key (sp, "content");
sp->string_len (sp, (char *) part_content->data, part_content->len);
show: Further general simplifications of the JSON formatter
2012-02-20 01:26:30 +01:00
g_object_unref (stream_memory);
show: indicate charset for all omitted parts Write a "charset" field for all omitted parts for which it is applicable, not only text/html parts. Factor out the code to a separate function. It will be extended with more fields next.
2012-12-16 00:22:50 +01:00
} else {
show: indicate length, encoding of omitted body content If a leaf part's body content is omitted, return the encoded length and transfer encoding in --format=json output. This information may be used by the consumer, e.g. to decide whether to download a large attachment over a slow link. Returning the _encoded_ content length is more efficient than returning the _decoded_ content length. Returning the transfer encoding allows the consumer to estimate the decoded content length.
2012-12-16 00:24:23 +01:00
format_omitted_part_meta_sprinter (sp, meta, GMIME_PART (node->part));
show: Convert JSON format to the new self-recursive style As before, this is all code movement and a smidgen of glue. This moves the existing JSON formatter code into one self-recursive function, but doesn't change any of the logic to take advantage of the new structure. In general, "leafs" of the JSON structure are left in helper functions (most of them untouched), so that it's easy to see the overall structure of the format from the main recursive function.
2012-02-20 01:26:24 +01:00
}
show: Further general simplifications of the JSON formatter
2012-02-20 01:26:30 +01:00
} else if (GMIME_IS_MULTIPART (node->part)) {
show: Convert non-envelope format_part_json to use sprinter
2012-08-03 03:14:55 +02:00
sp->map_key (sp, "content");
sp->begin_list (sp);
nclose = 1;
show: Further general simplifications of the JSON formatter
2012-02-20 01:26:30 +01:00
} else if (GMIME_IS_MESSAGE (node->part)) {
show: Convert non-envelope format_part_json to use sprinter
2012-08-03 03:14:55 +02:00
sp->map_key (sp, "content");
sp->begin_list (sp);
sp->begin_map (sp);
sp->map_key (sp, "headers");
Rename the -json printer functions in notmuch-reply and notmuch-show to generic -sprinter functions. All the structured output functions in notmuch-reply and notmuch-show are renamed to a generic name (as they do not contain any json-specific code anyway). This patch is a preparation to actually using the new S-Expression sprinter in notmuch-reply and notmuch-show.
2012-12-06 22:12:12 +01:00
format_headers_sprinter (sp, GMIME_MESSAGE (node->part), FALSE);
show: Convert JSON format to the new self-recursive style As before, this is all code movement and a smidgen of glue. This moves the existing JSON formatter code into one self-recursive function, but doesn't change any of the logic to take advantage of the new structure. In general, "leafs" of the JSON structure are left in helper functions (most of them untouched), so that it's easy to see the overall structure of the format from the main recursive function.
2012-02-20 01:26:24 +01:00
show: Convert non-envelope format_part_json to use sprinter
2012-08-03 03:14:55 +02:00
sp->map_key (sp, "body");
sp->begin_list (sp);
nclose = 3;
show: Convert JSON format to the new self-recursive style As before, this is all code movement and a smidgen of glue. This moves the existing JSON formatter code into one self-recursive function, but doesn't change any of the logic to take advantage of the new structure. In general, "leafs" of the JSON structure are left in helper functions (most of them untouched), so that it's easy to see the overall structure of the format from the main recursive function.
2012-02-20 01:26:24 +01:00
}
for (i = 0; i < node->nchildren; i++)
cli: add --include-html option to notmuch show For my client, the largest bottleneck for displaying large threads is exporting each html part individually since by default notmuch will not show the json parts. For large threads there can be quite a few parts and each must be exported and decoded one by one. Also, I then have to deal with all the crazy charsets which I can do through a library but is a pain. Therefore, this patch adds an --include-html option that causes the text/html parts to be included as part of the output of show. diff man/man1/notmuch-show.1
2013-07-02 02:19:42 +02:00
format_part_sprinter (ctx, sp, mime_node_child (node, i), i == 0, TRUE, include_html);
show: Convert JSON format to the new self-recursive style As before, this is all code movement and a smidgen of glue. This moves the existing JSON formatter code into one self-recursive function, but doesn't change any of the logic to take advantage of the new structure. In general, "leafs" of the JSON structure are left in helper functions (most of them untouched), so that it's easy to see the overall structure of the format from the main recursive function.
2012-02-20 01:26:24 +01:00
show: Convert non-envelope format_part_json to use sprinter
2012-08-03 03:14:55 +02:00
/* Close content structures */
for (i = 0; i < nclose; i++)
sp->end (sp);
/* Close part map */
sp->end (sp);
show: Convert JSON format to the new self-recursive style As before, this is all code movement and a smidgen of glue. This moves the existing JSON formatter code into one self-recursive function, but doesn't change any of the logic to take advantage of the new structure. In general, "leafs" of the JSON structure are left in helper functions (most of them untouched), so that it's easy to see the overall structure of the format from the main recursive function.
2012-02-20 01:26:24 +01:00
}
show: Allow formatters to return errors Formatter errors are propagated to the exit status of notmuch show. This isn't used by the JSON or text formatters, but it will be useful for the raw format, which is pickier.
2012-03-06 19:48:39 +01:00
static notmuch_status_t
Rename the -json printer functions in notmuch-reply and notmuch-show to generic -sprinter functions. All the structured output functions in notmuch-reply and notmuch-show are renamed to a generic name (as they do not contain any json-specific code anyway). This patch is a preparation to actually using the new S-Expression sprinter in notmuch-reply and notmuch-show.
2012-12-06 22:12:12 +01:00
format_part_sprinter_entry (const void *ctx, sprinter_t *sp,
mime_node_t *node, unused (int indent),
const notmuch_show_params_t *params)
show: Convert JSON format to the new self-recursive style As before, this is all code movement and a smidgen of glue. This moves the existing JSON formatter code into one self-recursive function, but doesn't change any of the logic to take advantage of the new structure. In general, "leafs" of the JSON structure are left in helper functions (most of them untouched), so that it's easy to see the overall structure of the format from the main recursive function.
2012-02-20 01:26:24 +01:00
{
cli: add --include-html option to notmuch show For my client, the largest bottleneck for displaying large threads is exporting each html part individually since by default notmuch will not show the json parts. For large threads there can be quite a few parts and each must be exported and decoded one by one. Also, I then have to deal with all the crazy charsets which I can do through a library but is a pain. Therefore, this patch adds an --include-html option that causes the text/html parts to be included as part of the output of show. diff man/man1/notmuch-show.1
2013-07-02 02:19:42 +02:00
format_part_sprinter (ctx, sp, node, TRUE, params->output_body, params->include_html);
show: Allow formatters to return errors Formatter errors are propagated to the exit status of notmuch show. This isn't used by the JSON or text formatters, but it will be useful for the raw format, which is pickier.
2012-03-06 19:48:39 +01:00
return NOTMUCH_STATUS_SUCCESS;
show: Convert JSON format to the new self-recursive style As before, this is all code movement and a smidgen of glue. This moves the existing JSON formatter code into one self-recursive function, but doesn't change any of the logic to take advantage of the new structure. In general, "leafs" of the JSON structure are left in helper functions (most of them untouched), so that it's easy to see the overall structure of the format from the main recursive function.
2012-02-20 01:26:24 +01:00
}
show: Move format_message_mbox with the other new-style formats Just code motion.
2012-03-06 19:48:40 +01:00
/* Print a message in "mboxrd" format as documented, for example,
* here:
*
* http://qmail.org/qmail-manual-html/man5/mbox.html
*/
show: Convert mbox format to new self-recursive style Given the lack of recursion, this is pretty easy.
2012-03-06 19:48:41 +01:00
static notmuch_status_t
show: Feed the sprinter down to part formatters There are several levels of function calls between where we create the sprinter and the call to the part formatter in show_message. This feeds the sprinter through all of them and into the part formatters.
2012-08-03 03:14:52 +02:00
format_part_mbox (const void *ctx, unused (sprinter_t *sp), mime_node_t *node,
unused (int indent),
show: Convert mbox format to new self-recursive style Given the lack of recursion, this is pretty easy.
2012-03-06 19:48:41 +01:00
unused (const notmuch_show_params_t *params))
show: Move format_message_mbox with the other new-style formats Just code motion.
2012-03-06 19:48:40 +01:00
{
show: Convert mbox format to new self-recursive style Given the lack of recursion, this is pretty easy.
2012-03-06 19:48:41 +01:00
notmuch_message_t *message = node->envelope_file;
show: Move format_message_mbox with the other new-style formats Just code motion.
2012-03-06 19:48:40 +01:00
const char *filename;
FILE *file;
const char *from;
time_t date;
struct tm date_gmtime;
char date_asctime[26];
char *line = NULL;
size_t line_size;
ssize_t line_len;
show: Convert mbox format to new self-recursive style Given the lack of recursion, this is pretty easy.
2012-03-06 19:48:41 +01:00
if (!message)
INTERNAL_ERROR ("format_part_mbox requires a root part");
show: Move format_message_mbox with the other new-style formats Just code motion.
2012-03-06 19:48:40 +01:00
filename = notmuch_message_get_filename (message);
file = fopen (filename, "r");
if (file == NULL) {
fprintf (stderr, "Failed to open %s: %s\n",
filename, strerror (errno));
show: Convert mbox format to new self-recursive style Given the lack of recursion, this is pretty easy.
2012-03-06 19:48:41 +01:00
return NOTMUCH_STATUS_FILE_ERROR;
show: Move format_message_mbox with the other new-style formats Just code motion.
2012-03-06 19:48:40 +01:00
}
from = notmuch_message_get_header (message, "from");
from = _extract_email_address (ctx, from);
date = notmuch_message_get_date (message);
gmtime_r (&date, &date_gmtime);
asctime_r (&date_gmtime, date_asctime);
printf ("From %s %s", from, date_asctime);
while ((line_len = getline (&line, &line_size, file)) != -1 ) {
if (_is_from_line (line))
putchar ('>');
printf ("%s", line);
}
printf ("\n");
fclose (file);
show: Convert mbox format to new self-recursive style Given the lack of recursion, this is pretty easy.
2012-03-06 19:48:41 +01:00
return NOTMUCH_STATUS_SUCCESS;
show: Move format_message_mbox with the other new-style formats Just code motion.
2012-03-06 19:48:40 +01:00
}
show: Convert raw format to the new self-recursive style, properly support interior parts This is fully compatible for root and leaf parts, but now has proper support for interior parts. This requires some design decisions that were guided by what I would want if I were to save a part. Specifically: - Leaf parts are printed without headers and with transfer decoding. This is what makes sense for saving attachments. (Furthermore, the transfer decoding is necessary since, without the headers, the caller would not be able to interpret non-transfer-decoded output.) - Message parts are printed with their message headers, but without enclosing part headers. This is what makes sense for saving a message as a whole (which is a message part) and for saving attached messages. This is symmetric for whole messages and for attached messages, though we special-case the whole message for performance reasons (and corner-case correctness reasons: given malformed input, GMime may not be able to reproduce it from the parsed representation). - Multipart parts are printed with their headers and all child parts. It's not clear what the best thing to do for multipart is, but this was the most natural to implement and can be justified because such parts can't be interpreted without their headers. As an added benefit, we can move the special-case code for part 0 into the raw formatter.
2012-03-06 19:48:43 +01:00
static notmuch_status_t
show: Feed the sprinter down to part formatters There are several levels of function calls between where we create the sprinter and the call to the part formatter in show_message. This feeds the sprinter through all of them and into the part formatters.
2012-08-03 03:14:52 +02:00
format_part_raw (unused (const void *ctx), unused (sprinter_t *sp),
mime_node_t *node, unused (int indent),
show: Convert raw format to the new self-recursive style, properly support interior parts This is fully compatible for root and leaf parts, but now has proper support for interior parts. This requires some design decisions that were guided by what I would want if I were to save a part. Specifically: - Leaf parts are printed without headers and with transfer decoding. This is what makes sense for saving attachments. (Furthermore, the transfer decoding is necessary since, without the headers, the caller would not be able to interpret non-transfer-decoded output.) - Message parts are printed with their message headers, but without enclosing part headers. This is what makes sense for saving a message as a whole (which is a message part) and for saving attached messages. This is symmetric for whole messages and for attached messages, though we special-case the whole message for performance reasons (and corner-case correctness reasons: given malformed input, GMime may not be able to reproduce it from the parsed representation). - Multipart parts are printed with their headers and all child parts. It's not clear what the best thing to do for multipart is, but this was the most natural to implement and can be justified because such parts can't be interpreted without their headers. As an added benefit, we can move the special-case code for part 0 into the raw formatter.
2012-03-06 19:48:43 +01:00
unused (const notmuch_show_params_t *params))
show: Move format_part_content_raw with the other new-style formats Just code motion.
2012-03-06 19:48:42 +01:00
{
show: Convert raw format to the new self-recursive style, properly support interior parts This is fully compatible for root and leaf parts, but now has proper support for interior parts. This requires some design decisions that were guided by what I would want if I were to save a part. Specifically: - Leaf parts are printed without headers and with transfer decoding. This is what makes sense for saving attachments. (Furthermore, the transfer decoding is necessary since, without the headers, the caller would not be able to interpret non-transfer-decoded output.) - Message parts are printed with their message headers, but without enclosing part headers. This is what makes sense for saving a message as a whole (which is a message part) and for saving attached messages. This is symmetric for whole messages and for attached messages, though we special-case the whole message for performance reasons (and corner-case correctness reasons: given malformed input, GMime may not be able to reproduce it from the parsed representation). - Multipart parts are printed with their headers and all child parts. It's not clear what the best thing to do for multipart is, but this was the most natural to implement and can be justified because such parts can't be interpreted without their headers. As an added benefit, we can move the special-case code for part 0 into the raw formatter.
2012-03-06 19:48:43 +01:00
if (node->envelope_file) {
/* Special case the entire message to avoid MIME parsing. */
const char *filename;
FILE *file;
size_t size;
char buf[4096];
filename = notmuch_message_get_filename (node->envelope_file);
if (filename == NULL) {
fprintf (stderr, "Error: Cannot get message filename.\n");
return NOTMUCH_STATUS_FILE_ERROR;
}
file = fopen (filename, "r");
if (file == NULL) {
fprintf (stderr, "Error: Cannot open file %s: %s\n", filename, strerror (errno));
return NOTMUCH_STATUS_FILE_ERROR;
}
while (!feof (file)) {
size = fread (buf, 1, sizeof (buf), file);
if (ferror (file)) {
fprintf (stderr, "Error: Read failed from %s\n", filename);
fclose (file);
return NOTMUCH_STATUS_FILE_ERROR;
}
if (fwrite (buf, size, 1, stdout) != 1) {
fprintf (stderr, "Error: Write failed\n");
fclose (file);
return NOTMUCH_STATUS_FILE_ERROR;
}
}
fclose (file);
return NOTMUCH_STATUS_SUCCESS;
}
show: Move format_part_content_raw with the other new-style formats Just code motion.
2012-03-06 19:48:42 +01:00
GMimeStream *stream_stdout;
GMimeStream *stream_filter = NULL;
stream_stdout = g_mime_stream_file_new (stdout);
g_mime_stream_file_set_owner (GMIME_STREAM_FILE (stream_stdout), FALSE);
stream_filter = g_mime_stream_filter_new (stream_stdout);
show: Convert raw format to the new self-recursive style, properly support interior parts This is fully compatible for root and leaf parts, but now has proper support for interior parts. This requires some design decisions that were guided by what I would want if I were to save a part. Specifically: - Leaf parts are printed without headers and with transfer decoding. This is what makes sense for saving attachments. (Furthermore, the transfer decoding is necessary since, without the headers, the caller would not be able to interpret non-transfer-decoded output.) - Message parts are printed with their message headers, but without enclosing part headers. This is what makes sense for saving a message as a whole (which is a message part) and for saving attached messages. This is symmetric for whole messages and for attached messages, though we special-case the whole message for performance reasons (and corner-case correctness reasons: given malformed input, GMime may not be able to reproduce it from the parsed representation). - Multipart parts are printed with their headers and all child parts. It's not clear what the best thing to do for multipart is, but this was the most natural to implement and can be justified because such parts can't be interpreted without their headers. As an added benefit, we can move the special-case code for part 0 into the raw formatter.
2012-03-06 19:48:43 +01:00
if (GMIME_IS_PART (node->part)) {
/* For leaf parts, we emit only the transfer-decoded
* body. */
GMimeDataWrapper *wrapper;
wrapper = g_mime_part_get_content_object (GMIME_PART (node->part));
show: Move format_part_content_raw with the other new-style formats Just code motion.
2012-03-06 19:48:42 +01:00
show: Convert raw format to the new self-recursive style, properly support interior parts This is fully compatible for root and leaf parts, but now has proper support for interior parts. This requires some design decisions that were guided by what I would want if I were to save a part. Specifically: - Leaf parts are printed without headers and with transfer decoding. This is what makes sense for saving attachments. (Furthermore, the transfer decoding is necessary since, without the headers, the caller would not be able to interpret non-transfer-decoded output.) - Message parts are printed with their message headers, but without enclosing part headers. This is what makes sense for saving a message as a whole (which is a message part) and for saving attached messages. This is symmetric for whole messages and for attached messages, though we special-case the whole message for performance reasons (and corner-case correctness reasons: given malformed input, GMime may not be able to reproduce it from the parsed representation). - Multipart parts are printed with their headers and all child parts. It's not clear what the best thing to do for multipart is, but this was the most natural to implement and can be justified because such parts can't be interpreted without their headers. As an added benefit, we can move the special-case code for part 0 into the raw formatter.
2012-03-06 19:48:43 +01:00
if (wrapper && stream_filter)
g_mime_data_wrapper_write_to_stream (wrapper, stream_filter);
} else {
/* Write out the whole part. For message parts (the root
* part and embedded message parts), this will be the
* message including its headers (but not the
* encapsulating part's headers). For multipart parts,
* this will include the headers. */
if (stream_filter)
g_mime_object_write_to_stream (node->part, stream_filter);
}
show: Move format_part_content_raw with the other new-style formats Just code motion.
2012-03-06 19:48:42 +01:00
if (stream_filter)
g_object_unref (stream_filter);
if (stream_stdout)
g_object_unref(stream_stdout);
show: Convert raw format to the new self-recursive style, properly support interior parts This is fully compatible for root and leaf parts, but now has proper support for interior parts. This requires some design decisions that were guided by what I would want if I were to save a part. Specifically: - Leaf parts are printed without headers and with transfer decoding. This is what makes sense for saving attachments. (Furthermore, the transfer decoding is necessary since, without the headers, the caller would not be able to interpret non-transfer-decoded output.) - Message parts are printed with their message headers, but without enclosing part headers. This is what makes sense for saving a message as a whole (which is a message part) and for saving attached messages. This is symmetric for whole messages and for attached messages, though we special-case the whole message for performance reasons (and corner-case correctness reasons: given malformed input, GMime may not be able to reproduce it from the parsed representation). - Multipart parts are printed with their headers and all child parts. It's not clear what the best thing to do for multipart is, but this was the most natural to implement and can be justified because such parts can't be interpreted without their headers. As an added benefit, we can move the special-case code for part 0 into the raw formatter.
2012-03-06 19:48:43 +01:00
return NOTMUCH_STATUS_SUCCESS;
show: Move format_part_content_raw with the other new-style formats Just code motion.
2012-03-06 19:48:42 +01:00
}
show: Allow formatters to return errors Formatter errors are propagated to the exit status of notmuch show. This isn't used by the JSON or text formatters, but it will be useful for the raw format, which is pickier.
2012-03-06 19:48:39 +01:00
static notmuch_status_t
pass entire format structure to various show_message functions Various show_message* functions require formatting functions, which were previously being passed individually as arguments. Since we will need to be needing to passing in more formatting function in the future (ie. for crypto support), we here modify things so that we just pass in the entire format structure. This will make things much simpler down the line as we need to pass in new format functions. We move the show_format structure into notmuch-client.c as notmuch_show_format. This also affects notmuch-reply.c, so we create a mostly-empty format_reply to pass the reply_part function to show_message_body.
2011-05-20 20:45:33 +02:00
show_message (void *ctx,
const notmuch_show_format_t *format,
show: Feed the sprinter down to part formatters There are several levels of function calls between where we create the sprinter and the call to the part formatter in show_message. This feeds the sprinter through all of them and into the part formatters.
2012-08-03 03:14:52 +02:00
sprinter_t *sp,
pass entire format structure to various show_message functions Various show_message* functions require formatting functions, which were previously being passed individually as arguments. Since we will need to be needing to passing in more formatting function in the future (ie. for crypto support), we here modify things so that we just pass in the entire format structure. This will make things much simpler down the line as we need to pass in new format functions. We move the show_format structure into notmuch-client.c as notmuch_show_format. This also affects notmuch-reply.c, so we create a mostly-empty format_reply to pass the reply_part function to show_message_body.
2011-05-20 20:45:33 +02:00
notmuch_message_t *message,
New part output handling as option to notmuch-show. Outputting of single MIME parts is moved to an option of notmuch show, instead of being handled in it's own sub-command. The recent rework of multipart mime allowed for this change but consolidating part handling into a single recursive function (show_message_part) that includes formatting. This allows for far simpler handling single output of a single part, including formatting.
2011-05-24 00:31:32 +02:00
int indent,
notmuch_show_params_t *params)
Add an "--format=(json|text)" command-line option to both notmuch-search and notmuch-show. In the case of notmuch-show, "--format=json" also implies "--entire-thread" as the thread structure is implicit in the emitted document tree. As a coincidence to the implementation, multipart message ID numbers are now incremented with each part printed. This changes the previous semantics, which were unclear and not necessary related to the actual ordering of the message parts.
2009-12-31 16:17:40 +01:00
{
show: Remove support for old-style formatters in show_message show_message used to have a compatibility path for old-style formatters. This removes that.
2012-04-08 02:57:46 +02:00
void *local = talloc_new (ctx);
mime_node_t *root, *part;
notmuch_status_t status;
show: Allow formatters to return errors Formatter errors are propagated to the exit status of notmuch show. This isn't used by the JSON or text formatters, but it will be useful for the raw format, which is pickier.
2012-03-06 19:48:39 +01:00
cli: modify mime_node_open to take new crypto struct as argument This simplifies the interface considerably.
2012-05-26 20:45:43 +02:00
status = mime_node_open (local, message, &(params->crypto), &root);
show: Remove support for old-style formatters in show_message show_message used to have a compatibility path for old-style formatters. This removes that.
2012-04-08 02:57:46 +02:00
if (status)
goto DONE;
part = mime_node_seek_dfs (root, (params->part < 0 ? 0 : params->part));
if (part)
show: Feed the sprinter down to part formatters There are several levels of function calls between where we create the sprinter and the call to the part formatter in show_message. This feeds the sprinter through all of them and into the part formatters.
2012-08-03 03:14:52 +02:00
status = format->part (local, sp, part, indent, params);
show: Remove support for old-style formatters in show_message show_message used to have a compatibility path for old-style formatters. This removes that.
2012-04-08 02:57:46 +02:00
DONE:
talloc_free (local);
return status;
New part output handling as option to notmuch-show. Outputting of single MIME parts is moved to an option of notmuch show, instead of being handled in it's own sub-command. The recent rework of multipart mime allowed for this change but consolidating part handling into a single recursive function (show_message_part) that includes formatting. This allows for far simpler handling single output of a single part, including formatting.
2011-05-24 00:31:32 +02:00
}
notmuch show: Implement proper thread ordering/nesting of messages. We now properly analyze the in-reply-to headers to create a proper tree representing the actual thread and present the messages in this correct thread order. Also, there's a new "depth:" value added to the "message{" header so that clients can format the thread as desired, (such as by indenting replies).
2009-11-16 05:39:25 +01:00
show: Allow formatters to return errors Formatter errors are propagated to the exit status of notmuch show. This isn't used by the JSON or text formatters, but it will be useful for the raw format, which is pickier.
2012-03-06 19:48:39 +01:00
static notmuch_status_t
pass entire format structure to various show_message functions Various show_message* functions require formatting functions, which were previously being passed individually as arguments. Since we will need to be needing to passing in more formatting function in the future (ie. for crypto support), we here modify things so that we just pass in the entire format structure. This will make things much simpler down the line as we need to pass in new format functions. We move the show_format structure into notmuch-client.c as notmuch_show_format. This also affects notmuch-reply.c, so we create a mostly-empty format_reply to pass the reply_part function to show_message_body.
2011-05-20 20:45:33 +02:00
show_messages (void *ctx,
const notmuch_show_format_t *format,
show: Feed the sprinter down to part formatters There are several levels of function calls between where we create the sprinter and the call to the part formatter in show_message. This feeds the sprinter through all of them and into the part formatters.
2012-08-03 03:14:52 +02:00
sprinter_t *sp,
pass entire format structure to various show_message functions Various show_message* functions require formatting functions, which were previously being passed individually as arguments. Since we will need to be needing to passing in more formatting function in the future (ie. for crypto support), we here modify things so that we just pass in the entire format structure. This will make things much simpler down the line as we need to pass in new format functions. We move the show_format structure into notmuch-client.c as notmuch_show_format. This also affects notmuch-reply.c, so we create a mostly-empty format_reply to pass the reply_part function to show_message_body.
2011-05-20 20:45:33 +02:00
notmuch_messages_t *messages,
int indent,
create notmuch_show_params_t structure for holding parameters passed to show functions. This simplifies the passing of arguments to the show functions. This will be very useful as we accumulate more parameters that will need to be passed. Currently only the entire_thread parameter is passed this way.
2011-05-21 00:01:52 +02:00
notmuch_show_params_t *params)
notmuch show: Implement proper thread ordering/nesting of messages. We now properly analyze the in-reply-to headers to create a proper tree representing the actual thread and present the messages in this correct thread order. Also, there's a new "depth:" value added to the "message{" header so that clients can format the thread as desired, (such as by indenting replies).
2009-11-16 05:39:25 +01:00
{
notmuch_message_t *message;
notmuch show: Preserve thread-ordering and nesting without --entire-thread When "notmuch show" was recently modified to not show an entire thread by default, it also lost all capability to properly order the messages in a thread and to print their proper depth. For example, the command: notmuch show thread:6d5e3e276461188c5778c9f219f63782 had dramatically different output than: notmuch show --entire-thread thread:6d5e3e276461188c5778c9f219f63782 even though both commands were selecting and displaying the same set of messages. The first command would diplay them "flat", (all with depth:0), and in strict date order; while the second command would display them "nested" (with depth based on threading), and in thread order. We now fix "notmuch show" without the --entire-thread option to also display nested and thread-ordered messages. If some messages in the thread are not included in the displayed results, then they are not counted when computing depth values.
2009-12-03 01:05:23 +01:00
notmuch_bool_t match;
cli: move show to the new --exclude= option naming scheme. This moves notmuch show to the --exclude=(true|false) naming scheme. When exclude=false show returns all threads that match including those that only match in an excluded message. The excluded messages are flagged. When exclude=true the behaviour depends on whether --entire-thread is set. If it is not set then show only returns the messages which match and are not excluded. If it is set then show returns all messages in the threads that match in a non-excluded message, flagging the excluded messages in these threads. The rationale is that it is awkward to use a thread with some missing messages.
2012-04-07 18:10:06 +02:00
notmuch_bool_t excluded;
notmuch show: Preserve thread-ordering and nesting without --entire-thread When "notmuch show" was recently modified to not show an entire thread by default, it also lost all capability to properly order the messages in a thread and to print their proper depth. For example, the command: notmuch show thread:6d5e3e276461188c5778c9f219f63782 had dramatically different output than: notmuch show --entire-thread thread:6d5e3e276461188c5778c9f219f63782 even though both commands were selecting and displaying the same set of messages. The first command would diplay them "flat", (all with depth:0), and in strict date order; while the second command would display them "nested" (with depth based on threading), and in thread order. We now fix "notmuch show" without the --entire-thread option to also display nested and thread-ordered messages. If some messages in the thread are not included in the displayed results, then they are not counted when computing depth values.
2009-12-03 01:05:23 +01:00
int next_indent;
show: Allow formatters to return errors Formatter errors are propagated to the exit status of notmuch show. This isn't used by the JSON or text formatters, but it will be useful for the raw format, which is pickier.
2012-03-06 19:48:39 +01:00
notmuch_status_t status, res = NOTMUCH_STATUS_SUCCESS;
notmuch show: Implement proper thread ordering/nesting of messages. We now properly analyze the in-reply-to headers to create a proper tree representing the actual thread and present the messages in this correct thread order. Also, there's a new "depth:" value added to the "message{" header so that clients can format the thread as desired, (such as by indenting replies).
2009-11-16 05:39:25 +01:00
show: Convert show_message to use sprinter Unlike the previous patches, this function is used for all formats. However, for formats other than the JSON format, the sprinter methods used by show_message are all no-ops, so this code continues to function correctly for all of the formats. Converting show_message eliminates show_null_message in the process, since this maps directly to an sprinter method.
2012-08-03 03:14:57 +02:00
sp->begin_list (sp);
Add an "--format=(json|text)" command-line option to both notmuch-search and notmuch-show. In the case of notmuch-show, "--format=json" also implies "--entire-thread" as the thread structure is implicit in the emitted document tree. As a coincidence to the implementation, multipart message ID numbers are now incremented with each part printed. This changes the previous semantics, which were unclear and not necessary related to the actual ordering of the message parts.
2009-12-31 16:17:40 +01:00
notmuch show: Implement proper thread ordering/nesting of messages. We now properly analyze the in-reply-to headers to create a proper tree representing the actual thread and present the messages in this correct thread order. Also, there's a new "depth:" value added to the "message{" header so that clients can format the thread as desired, (such as by indenting replies).
2009-11-16 05:39:25 +01:00
for (;
lib: Rename iterator functions to prepare for reverse iteration. We rename 'has_more' to 'valid' so that it can function whether iterating in a forward or reverse direction. We also rename 'advance' to 'move_to_next' to setup parallel naming with the proposed functions 'move_to_first', 'move_to_last', and 'move_to_previous'.
2010-03-09 18:22:29 +01:00
notmuch_messages_valid (messages);
notmuch_messages_move_to_next (messages))
notmuch show: Implement proper thread ordering/nesting of messages. We now properly analyze the in-reply-to headers to create a proper tree representing the actual thread and present the messages in this correct thread order. Also, there's a new "depth:" value added to the "message{" header so that clients can format the thread as desired, (such as by indenting replies).
2009-11-16 05:39:25 +01:00
{
show: Convert show_message to use sprinter Unlike the previous patches, this function is used for all formats. However, for formats other than the JSON format, the sprinter methods used by show_message are all no-ops, so this code continues to function correctly for all of the formats. Converting show_message eliminates show_null_message in the process, since this maps directly to an sprinter method.
2012-08-03 03:14:57 +02:00
sp->begin_list (sp);
Add an "--format=(json|text)" command-line option to both notmuch-search and notmuch-show. In the case of notmuch-show, "--format=json" also implies "--entire-thread" as the thread structure is implicit in the emitted document tree. As a coincidence to the implementation, multipart message ID numbers are now incremented with each part printed. This changes the previous semantics, which were unclear and not necessary related to the actual ordering of the message parts.
2009-12-31 16:17:40 +01:00
notmuch show: Implement proper thread ordering/nesting of messages. We now properly analyze the in-reply-to headers to create a proper tree representing the actual thread and present the messages in this correct thread order. Also, there's a new "depth:" value added to the "message{" header so that clients can format the thread as desired, (such as by indenting replies).
2009-11-16 05:39:25 +01:00
message = notmuch_messages_get (messages);
notmuch show: Preserve thread-ordering and nesting without --entire-thread When "notmuch show" was recently modified to not show an entire thread by default, it also lost all capability to properly order the messages in a thread and to print their proper depth. For example, the command: notmuch show thread:6d5e3e276461188c5778c9f219f63782 had dramatically different output than: notmuch show --entire-thread thread:6d5e3e276461188c5778c9f219f63782 even though both commands were selecting and displaying the same set of messages. The first command would diplay them "flat", (all with depth:0), and in strict date order; while the second command would display them "nested" (with depth based on threading), and in thread order. We now fix "notmuch show" without the --entire-thread option to also display nested and thread-ordered messages. If some messages in the thread are not included in the displayed results, then they are not counted when computing depth values.
2009-12-03 01:05:23 +01:00
match = notmuch_message_get_flag (message, NOTMUCH_MESSAGE_FLAG_MATCH);
cli: move show to the new --exclude= option naming scheme. This moves notmuch show to the --exclude=(true|false) naming scheme. When exclude=false show returns all threads that match including those that only match in an excluded message. The excluded messages are flagged. When exclude=true the behaviour depends on whether --entire-thread is set. If it is not set then show only returns the messages which match and are not excluded. If it is set then show returns all messages in the threads that match in a non-excluded message, flagging the excluded messages in these threads. The rationale is that it is awkward to use a thread with some missing messages.
2012-04-07 18:10:06 +02:00
excluded = notmuch_message_get_flag (message, NOTMUCH_MESSAGE_FLAG_EXCLUDED);
notmuch show: Implement proper thread ordering/nesting of messages. We now properly analyze the in-reply-to headers to create a proper tree representing the actual thread and present the messages in this correct thread order. Also, there's a new "depth:" value added to the "message{" header so that clients can format the thread as desired, (such as by indenting replies).
2009-11-16 05:39:25 +01:00
notmuch show: Preserve thread-ordering and nesting without --entire-thread When "notmuch show" was recently modified to not show an entire thread by default, it also lost all capability to properly order the messages in a thread and to print their proper depth. For example, the command: notmuch show thread:6d5e3e276461188c5778c9f219f63782 had dramatically different output than: notmuch show --entire-thread thread:6d5e3e276461188c5778c9f219f63782 even though both commands were selecting and displaying the same set of messages. The first command would diplay them "flat", (all with depth:0), and in strict date order; while the second command would display them "nested" (with depth based on threading), and in thread order. We now fix "notmuch show" without the --entire-thread option to also display nested and thread-ordered messages. If some messages in the thread are not included in the displayed results, then they are not counted when computing depth values.
2009-12-03 01:05:23 +01:00
next_indent = indent;
cli: move show to the new --exclude= option naming scheme. This moves notmuch show to the --exclude=(true|false) naming scheme. When exclude=false show returns all threads that match including those that only match in an excluded message. The excluded messages are flagged. When exclude=true the behaviour depends on whether --entire-thread is set. If it is not set then show only returns the messages which match and are not excluded. If it is set then show returns all messages in the threads that match in a non-excluded message, flagging the excluded messages in these threads. The rationale is that it is awkward to use a thread with some missing messages.
2012-04-07 18:10:06 +02:00
if ((match && (!excluded || !params->omit_excluded)) || params->entire_thread) {
show: Feed the sprinter down to part formatters There are several levels of function calls between where we create the sprinter and the call to the part formatter in show_message. This feeds the sprinter through all of them and into the part formatters.
2012-08-03 03:14:52 +02:00
status = show_message (ctx, format, sp, message, indent, params);
show: Allow formatters to return errors Formatter errors are propagated to the exit status of notmuch show. This isn't used by the JSON or text formatters, but it will be useful for the raw format, which is pickier.
2012-03-06 19:48:39 +01:00
if (status && !res)
res = status;
notmuch show: Preserve thread-ordering and nesting without --entire-thread When "notmuch show" was recently modified to not show an entire thread by default, it also lost all capability to properly order the messages in a thread and to print their proper depth. For example, the command: notmuch show thread:6d5e3e276461188c5778c9f219f63782 had dramatically different output than: notmuch show --entire-thread thread:6d5e3e276461188c5778c9f219f63782 even though both commands were selecting and displaying the same set of messages. The first command would diplay them "flat", (all with depth:0), and in strict date order; while the second command would display them "nested" (with depth based on threading), and in thread order. We now fix "notmuch show" without the --entire-thread option to also display nested and thread-ordered messages. If some messages in the thread are not included in the displayed results, then they are not counted when computing depth values.
2009-12-03 01:05:23 +01:00
next_indent = indent + 1;
cli: Let json output "null" messages for non --entire-thread All formats except Json can output empty messages for non entire-thread, but in Json format we output "null" to keep the other elements (e.g. the replies to the omitted message) in the correct place.
2012-06-16 12:21:43 +02:00
} else {
show: Convert show_message to use sprinter Unlike the previous patches, this function is used for all formats. However, for formats other than the JSON format, the sprinter methods used by show_message are all no-ops, so this code continues to function correctly for all of the formats. Converting show_message eliminates show_null_message in the process, since this maps directly to an sprinter method.
2012-08-03 03:14:57 +02:00
sp->null (sp);
notmuch show: Preserve thread-ordering and nesting without --entire-thread When "notmuch show" was recently modified to not show an entire thread by default, it also lost all capability to properly order the messages in a thread and to print their proper depth. For example, the command: notmuch show thread:6d5e3e276461188c5778c9f219f63782 had dramatically different output than: notmuch show --entire-thread thread:6d5e3e276461188c5778c9f219f63782 even though both commands were selecting and displaying the same set of messages. The first command would diplay them "flat", (all with depth:0), and in strict date order; while the second command would display them "nested" (with depth based on threading), and in thread order. We now fix "notmuch show" without the --entire-thread option to also display nested and thread-ordered messages. If some messages in the thread are not included in the displayed results, then they are not counted when computing depth values.
2009-12-03 01:05:23 +01:00
}
show: Allow formatters to return errors Formatter errors are propagated to the exit status of notmuch show. This isn't used by the JSON or text formatters, but it will be useful for the raw format, which is pickier.
2012-03-06 19:48:39 +01:00
status = show_messages (ctx,
show: Feed the sprinter down to part formatters There are several levels of function calls between where we create the sprinter and the call to the part formatter in show_message. This feeds the sprinter through all of them and into the part formatters.
2012-08-03 03:14:52 +02:00
format, sp,
show: Allow formatters to return errors Formatter errors are propagated to the exit status of notmuch show. This isn't used by the JSON or text formatters, but it will be useful for the raw format, which is pickier.
2012-03-06 19:48:39 +01:00
notmuch_message_get_replies (message),
next_indent,
params);
if (status && !res)
res = status;
notmuch show: Implement proper thread ordering/nesting of messages. We now properly analyze the in-reply-to headers to create a proper tree representing the actual thread and present the messages in this correct thread order. Also, there's a new "depth:" value added to the "message{" header so that clients can format the thread as desired, (such as by indenting replies).
2009-11-16 05:39:25 +01:00
notmuch_message_destroy (message);
Add an "--format=(json|text)" command-line option to both notmuch-search and notmuch-show. In the case of notmuch-show, "--format=json" also implies "--entire-thread" as the thread structure is implicit in the emitted document tree. As a coincidence to the implementation, multipart message ID numbers are now incremented with each part printed. This changes the previous semantics, which were unclear and not necessary related to the actual ordering of the message parts.
2009-12-31 16:17:40 +01:00
show: Convert show_message to use sprinter Unlike the previous patches, this function is used for all formats. However, for formats other than the JSON format, the sprinter methods used by show_message are all no-ops, so this code continues to function correctly for all of the formats. Converting show_message eliminates show_null_message in the process, since this maps directly to an sprinter method.
2012-08-03 03:14:57 +02:00
sp->end (sp);
notmuch show: Implement proper thread ordering/nesting of messages. We now properly analyze the in-reply-to headers to create a proper tree representing the actual thread and present the messages in this correct thread order. Also, there's a new "depth:" value added to the "message{" header so that clients can format the thread as desired, (such as by indenting replies).
2009-11-16 05:39:25 +01:00
}
Add an "--format=(json|text)" command-line option to both notmuch-search and notmuch-show. In the case of notmuch-show, "--format=json" also implies "--entire-thread" as the thread structure is implicit in the emitted document tree. As a coincidence to the implementation, multipart message ID numbers are now incremented with each part printed. This changes the previous semantics, which were unclear and not necessary related to the actual ordering of the message parts.
2009-12-31 16:17:40 +01:00
show: Convert show_message to use sprinter Unlike the previous patches, this function is used for all formats. However, for formats other than the JSON format, the sprinter methods used by show_message are all no-ops, so this code continues to function correctly for all of the formats. Converting show_message eliminates show_null_message in the process, since this maps directly to an sprinter method.
2012-08-03 03:14:57 +02:00
sp->end (sp);
show: Allow formatters to return errors Formatter errors are propagated to the exit status of notmuch show. This isn't used by the JSON or text formatters, but it will be useful for the raw format, which is pickier.
2012-03-06 19:48:39 +01:00
return res;
notmuch show: Implement proper thread ordering/nesting of messages. We now properly analyze the in-reply-to headers to create a proper tree representing the actual thread and present the messages in this correct thread order. Also, there's a new "depth:" value added to the "message{" header so that clients can format the thread as desired, (such as by indenting replies).
2009-11-16 05:39:25 +01:00
}
rename do_show_raw to do_show_single, and create params.raw for raw message output We rename here in order to make do_show_single into a generic function for handling output of just a single message, or which format=raw is a special case. The raw case is handled by setting a new parameter, params.raw, which is used to tell do_show_single to output a single message as a raw file. This is mostly in preparation for much improved part handling to follow imminently.
2011-05-23 05:04:02 +02:00
/* Formatted output of single message */
Rename "notmuch cat" to "notmuch show --format=raw" This is part of an effort to avoid proliferation of excessive top-level notmuch commands. Also, "raw" better captures the functionality here, (as opposed to "cat" which is a fairly oblique reference to a bad Unix abbreviation whose metaphor doesn't work here since "notmuch cat" operates only on a single message and hence cannot "con'cat'enate" anything).
2010-11-06 20:03:51 +01:00
static int
rename do_show_raw to do_show_single, and create params.raw for raw message output We rename here in order to make do_show_single into a generic function for handling output of just a single message, or which format=raw is a special case. The raw case is handled by setting a new parameter, params.raw, which is used to tell do_show_single to output a single message as a raw file. This is mostly in preparation for much improved part handling to follow imminently.
2011-05-23 05:04:02 +02:00
do_show_single (void *ctx,
notmuch_query_t *query,
const notmuch_show_format_t *format,
show: Feed the sprinter down to part formatters There are several levels of function calls between where we create the sprinter and the call to the part formatter in show_message. This feeds the sprinter through all of them and into the part formatters.
2012-08-03 03:14:52 +02:00
sprinter_t *sp,
rename do_show_raw to do_show_single, and create params.raw for raw message output We rename here in order to make do_show_single into a generic function for handling output of just a single message, or which format=raw is a special case. The raw case is handled by setting a new parameter, params.raw, which is used to tell do_show_single to output a single message as a raw file. This is mostly in preparation for much improved part handling to follow imminently.
2011-05-23 05:04:02 +02:00
notmuch_show_params_t *params)
notmuch: Break notmuch.c up into several smaller files. Now that the client sources are alone here in their own directory, (with all the library sources down inside the lib directory), we can break the client up into multiple files without mixing the files up. The hope is that these smaller files will be easier to manage and maintain.
2009-11-10 21:03:05 +01:00
{
notmuch_messages_t *messages;
Rename "notmuch cat" to "notmuch show --format=raw" This is part of an effort to avoid proliferation of excessive top-level notmuch commands. Also, "raw" better captures the functionality here, (as opposed to "cat" which is a fairly oblique reference to a bad Unix abbreviation whose metaphor doesn't work here since "notmuch cat" operates only on a single message and hence cannot "con'cat'enate" anything).
2010-11-06 20:03:51 +01:00
notmuch_message_t *message;
cli: convert remainder of CLI to n_q_search_{messages,threads}_st I think it would be no real problem to cut and paste the gdb based error message test from count to the other clients modified here, but I'm not currently convinced it's worth the trouble since the code path being tested is almost the the same, and the tests are relatively heavyweight.
2015-09-06 15:15:47 +02:00
notmuch_status_t status;
cli: update to use new count API Essentially replace each call to notmuch_count_* with the corresponding _st call, followed by print_status_query.
2015-09-27 17:31:58 +02:00
unsigned int count;
notmuch show: limit display to only matching messages This patch changes the default behaviour of notmuch show to display only messages that match the search expression. However, --entire-thread option is provided to display all messages in threads that matched the search expression. It is deemed that will be more useful for human users on the command line. Scripts can be modified to include the --entire-thread option so that they can display all messages once more. Example: $ notmuch search subject:git AND thread:23d99d0f364f93e90e15df8b42eddb5b thread:23d99d0f364f93e90e15df8b42eddb5b July 31 [4/12] Johan Herland; [RFCv2 00/12] Foreign VCS helper program for CVS repositories (inbox unread) Note that in this thread 4 out of 12 messages matched. The default show behaviour is to show only those messages that match: $ notmuch show subject:git AND thread:23d99d0f364f93e90e15df8b42eddb5b | grep 'message{' | wc -l 4 With the --entire-thread option the output will contain all dozen messages: $ notmuch show --entire-thread subject:git AND thread:23d99d0f364f93e90e15df8b42eddb5b | grep 'message{' | wc -l 12 Signed-off-by: Bart Trojanowski <bart@jukie.net>
2009-11-28 03:49:39 +01:00
cli: update to use new count API Essentially replace each call to notmuch_count_* with the corresponding _st call, followed by print_status_query.
2015-09-27 17:31:58 +02:00
status = notmuch_query_count_messages_st (query, &count);
if (print_status_query ("notmuch show", query, status))
return 1;
if (count != 1) {
cli: tell how many messages were precisely matched when expected 1 match In case of notmuch reply and notmuch show --part=N it is required that search terms match to one message. If match count was != 1, error message "Error: search term did not match precisely one message" was too vague to explain what happened. By appending (matched <num> messages) to the error message it makes the problem more understandable (e.g when <num> is '0' user reckons the query had a typo in it).
2016-05-07 21:24:18 +02:00
fprintf (stderr, "Error: search term did not match precisely one message (matched %d messages).\n", count);
Rename "notmuch cat" to "notmuch show --format=raw" This is part of an effort to avoid proliferation of excessive top-level notmuch commands. Also, "raw" better captures the functionality here, (as opposed to "cat" which is a fairly oblique reference to a bad Unix abbreviation whose metaphor doesn't work here since "notmuch cat" operates only on a single message and hence cannot "con'cat'enate" anything).
2010-11-06 20:03:51 +01:00
return 1;
notmuch show: limit display to only matching messages This patch changes the default behaviour of notmuch show to display only messages that match the search expression. However, --entire-thread option is provided to display all messages in threads that matched the search expression. It is deemed that will be more useful for human users on the command line. Scripts can be modified to include the --entire-thread option so that they can display all messages once more. Example: $ notmuch search subject:git AND thread:23d99d0f364f93e90e15df8b42eddb5b thread:23d99d0f364f93e90e15df8b42eddb5b July 31 [4/12] Johan Herland; [RFCv2 00/12] Foreign VCS helper program for CVS repositories (inbox unread) Note that in this thread 4 out of 12 messages matched. The default show behaviour is to show only those messages that match: $ notmuch show subject:git AND thread:23d99d0f364f93e90e15df8b42eddb5b | grep 'message{' | wc -l 4 With the --entire-thread option the output will contain all dozen messages: $ notmuch show --entire-thread subject:git AND thread:23d99d0f364f93e90e15df8b42eddb5b | grep 'message{' | wc -l 12 Signed-off-by: Bart Trojanowski <bart@jukie.net>
2009-11-28 03:49:39 +01:00
}
cli: convert remainder of CLI to n_q_search_{messages,threads}_st I think it would be no real problem to cut and paste the gdb based error message test from count to the other clients modified here, but I'm not currently convinced it's worth the trouble since the code path being tested is almost the the same, and the tests are relatively heavyweight.
2015-09-06 15:15:47 +02:00
status = notmuch_query_search_messages_st (query, &messages);
if (print_status_query ("notmuch show", query, status))
return 1;
Rename "notmuch cat" to "notmuch show --format=raw" This is part of an effort to avoid proliferation of excessive top-level notmuch commands. Also, "raw" better captures the functionality here, (as opposed to "cat" which is a fairly oblique reference to a bad Unix abbreviation whose metaphor doesn't work here since "notmuch cat" operates only on a single message and hence cannot "con'cat'enate" anything).
2010-11-06 20:03:51 +01:00
message = notmuch_messages_get (messages);
notmuch: Break notmuch.c up into several smaller files. Now that the client sources are alone here in their own directory, (with all the library sources down inside the lib directory), we can break the client up into multiple files without mixing the files up. The hope is that these smaller files will be easier to manage and maintain.
2009-11-10 21:03:05 +01:00
Rename "notmuch cat" to "notmuch show --format=raw" This is part of an effort to avoid proliferation of excessive top-level notmuch commands. Also, "raw" better captures the functionality here, (as opposed to "cat" which is a fairly oblique reference to a bad Unix abbreviation whose metaphor doesn't work here since "notmuch cat" operates only on a single message and hence cannot "con'cat'enate" anything).
2010-11-06 20:03:51 +01:00
if (message == NULL) {
fprintf (stderr, "Error: Cannot find matching message.\n");
Unbreak several notmuch commands after the addition of configuration. All of the following commands: notmuch dump notmuch reply notmuch restore notmuch search notmuch show notmuch tag were calling notmuch_database_open with an argument of NULL. This was a legitimate call until the recent addition of configuration, after which it is expected that all commands will lookup the correct path in the configuration file. So fix all these commands to do that. Also, while touching all of these commands, we fix them to use the talloc context that is passed in rather than creating a local talloc context. We also switch from using goto for return values, to doing direct returns as soon as an error is detected, (which can be leak free thanks to talloc).
2009-11-12 05:29:30 +01:00
return 1;
notmuch: Break notmuch.c up into several smaller files. Now that the client sources are alone here in their own directory, (with all the library sources down inside the lib directory), we can break the client up into multiple files without mixing the files up. The hope is that these smaller files will be easier to manage and maintain.
2009-11-10 21:03:05 +01:00
}
New part output handling as option to notmuch-show. Outputting of single MIME parts is moved to an option of notmuch show, instead of being handled in it's own sub-command. The recent rework of multipart mime allowed for this change but consolidating part handling into a single recursive function (show_message_part) that includes formatting. This allows for far simpler handling single output of a single part, including formatting.
2011-05-24 00:31:32 +02:00
notmuch_message_set_flag (message, NOTMUCH_MESSAGE_FLAG_MATCH, 1);
show: Feed the sprinter down to part formatters There are several levels of function calls between where we create the sprinter and the call to the part formatter in show_message. This feeds the sprinter through all of them and into the part formatters.
2012-08-03 03:14:52 +02:00
return show_message (ctx, format, sp, message, 0, params)
!= NOTMUCH_STATUS_SUCCESS;
Rename "notmuch cat" to "notmuch show --format=raw" This is part of an effort to avoid proliferation of excessive top-level notmuch commands. Also, "raw" better captures the functionality here, (as opposed to "cat" which is a fairly oblique reference to a bad Unix abbreviation whose metaphor doesn't work here since "notmuch cat" operates only on a single message and hence cannot "con'cat'enate" anything).
2010-11-06 20:03:51 +01:00
}
rename do_show_raw to do_show_single, and create params.raw for raw message output We rename here in order to make do_show_single into a generic function for handling output of just a single message, or which format=raw is a special case. The raw case is handled by setting a new parameter, params.raw, which is used to tell do_show_single to output a single message as a raw file. This is mostly in preparation for much improved part handling to follow imminently.
2011-05-23 05:04:02 +02:00
/* Formatted output of threads */
Rename "notmuch cat" to "notmuch show --format=raw" This is part of an effort to avoid proliferation of excessive top-level notmuch commands. Also, "raw" better captures the functionality here, (as opposed to "cat" which is a fairly oblique reference to a bad Unix abbreviation whose metaphor doesn't work here since "notmuch cat" operates only on a single message and hence cannot "con'cat'enate" anything).
2010-11-06 20:03:51 +01:00
static int
do_show (void *ctx,
notmuch_query_t *query,
pass entire format structure to various show_message functions Various show_message* functions require formatting functions, which were previously being passed individually as arguments. Since we will need to be needing to passing in more formatting function in the future (ie. for crypto support), we here modify things so that we just pass in the entire format structure. This will make things much simpler down the line as we need to pass in new format functions. We move the show_format structure into notmuch-client.c as notmuch_show_format. This also affects notmuch-reply.c, so we create a mostly-empty format_reply to pass the reply_part function to show_message_body.
2011-05-20 20:45:33 +02:00
const notmuch_show_format_t *format,
show: Feed the sprinter down to part formatters There are several levels of function calls between where we create the sprinter and the call to the part formatter in show_message. This feeds the sprinter through all of them and into the part formatters.
2012-08-03 03:14:52 +02:00
sprinter_t *sp,
create notmuch_show_params_t structure for holding parameters passed to show functions. This simplifies the passing of arguments to the show functions. This will be very useful as we accumulate more parameters that will need to be passed. Currently only the entire_thread parameter is passed this way.
2011-05-21 00:01:52 +02:00
notmuch_show_params_t *params)
Rename "notmuch cat" to "notmuch show --format=raw" This is part of an effort to avoid proliferation of excessive top-level notmuch commands. Also, "raw" better captures the functionality here, (as opposed to "cat" which is a fairly oblique reference to a bad Unix abbreviation whose metaphor doesn't work here since "notmuch cat" operates only on a single message and hence cannot "con'cat'enate" anything).
2010-11-06 20:03:51 +01:00
{
notmuch_threads_t *threads;
notmuch_thread_t *thread;
notmuch_messages_t *messages;
show: Allow formatters to return errors Formatter errors are propagated to the exit status of notmuch show. This isn't used by the JSON or text formatters, but it will be useful for the raw format, which is pickier.
2012-03-06 19:48:39 +01:00
notmuch_status_t status, res = NOTMUCH_STATUS_SUCCESS;
Rename "notmuch cat" to "notmuch show --format=raw" This is part of an effort to avoid proliferation of excessive top-level notmuch commands. Also, "raw" better captures the functionality here, (as opposed to "cat" which is a fairly oblique reference to a bad Unix abbreviation whose metaphor doesn't work here since "notmuch cat" operates only on a single message and hence cannot "con'cat'enate" anything).
2010-11-06 20:03:51 +01:00
cli: convert remainder of CLI to n_q_search_{messages,threads}_st I think it would be no real problem to cut and paste the gdb based error message test from count to the other clients modified here, but I'm not currently convinced it's worth the trouble since the code path being tested is almost the the same, and the tests are relatively heavyweight.
2015-09-06 15:15:47 +02:00
status= notmuch_query_search_threads_st (query, &threads);
if (print_status_query ("notmuch show", query, status))
notmuch-show: detect NULL pointer returned from notmuch_query_search_threads We want to return an error status, not 0 or (worse) segfault.
2014-01-23 13:24:01 +01:00
return 1;
show: Convert do_show to use sprinter
2012-08-03 03:14:58 +02:00
sp->begin_list (sp);
Add an "--format=(json|text)" command-line option to both notmuch-search and notmuch-show. In the case of notmuch-show, "--format=json" also implies "--entire-thread" as the thread structure is implicit in the emitted document tree. As a coincidence to the implementation, multipart message ID numbers are now incremented with each part printed. This changes the previous semantics, which were unclear and not necessary related to the actual ordering of the message parts.
2009-12-31 16:17:40 +01:00
notmuch-show: detect NULL pointer returned from notmuch_query_search_threads We want to return an error status, not 0 or (worse) segfault.
2014-01-23 13:24:01 +01:00
for ( ;
lib: Rename iterator functions to prepare for reverse iteration. We rename 'has_more' to 'valid' so that it can function whether iterating in a forward or reverse direction. We also rename 'advance' to 'move_to_next' to setup parallel naming with the proposed functions 'move_to_first', 'move_to_last', and 'move_to_previous'.
2010-03-09 18:22:29 +01:00
notmuch_threads_valid (threads);
notmuch_threads_move_to_next (threads))
notmuch show: Preserve thread-ordering and nesting without --entire-thread When "notmuch show" was recently modified to not show an entire thread by default, it also lost all capability to properly order the messages in a thread and to print their proper depth. For example, the command: notmuch show thread:6d5e3e276461188c5778c9f219f63782 had dramatically different output than: notmuch show --entire-thread thread:6d5e3e276461188c5778c9f219f63782 even though both commands were selecting and displaying the same set of messages. The first command would diplay them "flat", (all with depth:0), and in strict date order; while the second command would display them "nested" (with depth based on threading), and in thread order. We now fix "notmuch show" without the --entire-thread option to also display nested and thread-ordered messages. If some messages in the thread are not included in the displayed results, then they are not counted when computing depth values.
2009-12-03 01:05:23 +01:00
{
thread = notmuch_threads_get (threads);
notmuch: Break notmuch.c up into several smaller files. Now that the client sources are alone here in their own directory, (with all the library sources down inside the lib directory), we can break the client up into multiple files without mixing the files up. The hope is that these smaller files will be easier to manage and maintain.
2009-11-10 21:03:05 +01:00
notmuch show: Preserve thread-ordering and nesting without --entire-thread When "notmuch show" was recently modified to not show an entire thread by default, it also lost all capability to properly order the messages in a thread and to print their proper depth. For example, the command: notmuch show thread:6d5e3e276461188c5778c9f219f63782 had dramatically different output than: notmuch show --entire-thread thread:6d5e3e276461188c5778c9f219f63782 even though both commands were selecting and displaying the same set of messages. The first command would diplay them "flat", (all with depth:0), and in strict date order; while the second command would display them "nested" (with depth based on threading), and in thread order. We now fix "notmuch show" without the --entire-thread option to also display nested and thread-ordered messages. If some messages in the thread are not included in the displayed results, then they are not counted when computing depth values.
2009-12-03 01:05:23 +01:00
messages = notmuch_thread_get_toplevel_messages (thread);
notmuch show: Detect an internal error if a thread has no messages. This really should be impossible---if there are no messages, then what was the thread object created from? During recent debugging, it was useful to have this error detected and reported.
2009-11-18 02:53:54 +01:00
notmuch show: Preserve thread-ordering and nesting without --entire-thread When "notmuch show" was recently modified to not show an entire thread by default, it also lost all capability to properly order the messages in a thread and to print their proper depth. For example, the command: notmuch show thread:6d5e3e276461188c5778c9f219f63782 had dramatically different output than: notmuch show --entire-thread thread:6d5e3e276461188c5778c9f219f63782 even though both commands were selecting and displaying the same set of messages. The first command would diplay them "flat", (all with depth:0), and in strict date order; while the second command would display them "nested" (with depth based on threading), and in thread order. We now fix "notmuch show" without the --entire-thread option to also display nested and thread-ordered messages. If some messages in the thread are not included in the displayed results, then they are not counted when computing depth values.
2009-12-03 01:05:23 +01:00
if (messages == NULL)
INTERNAL_ERROR ("Thread %s has no toplevel messages.\n",
notmuch_thread_get_thread_id (thread));
notmuch show: limit display to only matching messages This patch changes the default behaviour of notmuch show to display only messages that match the search expression. However, --entire-thread option is provided to display all messages in threads that matched the search expression. It is deemed that will be more useful for human users on the command line. Scripts can be modified to include the --entire-thread option so that they can display all messages once more. Example: $ notmuch search subject:git AND thread:23d99d0f364f93e90e15df8b42eddb5b thread:23d99d0f364f93e90e15df8b42eddb5b July 31 [4/12] Johan Herland; [RFCv2 00/12] Foreign VCS helper program for CVS repositories (inbox unread) Note that in this thread 4 out of 12 messages matched. The default show behaviour is to show only those messages that match: $ notmuch show subject:git AND thread:23d99d0f364f93e90e15df8b42eddb5b | grep 'message{' | wc -l 4 With the --entire-thread option the output will contain all dozen messages: $ notmuch show --entire-thread subject:git AND thread:23d99d0f364f93e90e15df8b42eddb5b | grep 'message{' | wc -l 12 Signed-off-by: Bart Trojanowski <bart@jukie.net>
2009-11-28 03:49:39 +01:00
show: Feed the sprinter down to part formatters There are several levels of function calls between where we create the sprinter and the call to the part formatter in show_message. This feeds the sprinter through all of them and into the part formatters.
2012-08-03 03:14:52 +02:00
status = show_messages (ctx, format, sp, messages, 0, params);
show: Allow formatters to return errors Formatter errors are propagated to the exit status of notmuch show. This isn't used by the JSON or text formatters, but it will be useful for the raw format, which is pickier.
2012-03-06 19:48:39 +01:00
if (status && !res)
res = status;
notmuch: Break notmuch.c up into several smaller files. Now that the client sources are alone here in their own directory, (with all the library sources down inside the lib directory), we can break the client up into multiple files without mixing the files up. The hope is that these smaller files will be easier to manage and maintain.
2009-11-10 21:03:05 +01:00
notmuch show: Preserve thread-ordering and nesting without --entire-thread When "notmuch show" was recently modified to not show an entire thread by default, it also lost all capability to properly order the messages in a thread and to print their proper depth. For example, the command: notmuch show thread:6d5e3e276461188c5778c9f219f63782 had dramatically different output than: notmuch show --entire-thread thread:6d5e3e276461188c5778c9f219f63782 even though both commands were selecting and displaying the same set of messages. The first command would diplay them "flat", (all with depth:0), and in strict date order; while the second command would display them "nested" (with depth based on threading), and in thread order. We now fix "notmuch show" without the --entire-thread option to also display nested and thread-ordered messages. If some messages in the thread are not included in the displayed results, then they are not counted when computing depth values.
2009-12-03 01:05:23 +01:00
notmuch_thread_destroy (thread);
Add an "--format=(json|text)" command-line option to both notmuch-search and notmuch-show. In the case of notmuch-show, "--format=json" also implies "--entire-thread" as the thread structure is implicit in the emitted document tree. As a coincidence to the implementation, multipart message ID numbers are now incremented with each part printed. This changes the previous semantics, which were unclear and not necessary related to the actual ordering of the message parts.
2009-12-31 16:17:40 +01:00
notmuch: Break notmuch.c up into several smaller files. Now that the client sources are alone here in their own directory, (with all the library sources down inside the lib directory), we can break the client up into multiple files without mixing the files up. The hope is that these smaller files will be easier to manage and maintain.
2009-11-10 21:03:05 +01:00
}
show: Convert do_show to use sprinter
2012-08-03 03:14:58 +02:00
sp->end (sp);
Add an "--format=(json|text)" command-line option to both notmuch-search and notmuch-show. In the case of notmuch-show, "--format=json" also implies "--entire-thread" as the thread structure is implicit in the emitted document tree. As a coincidence to the implementation, multipart message ID numbers are now incremented with each part printed. This changes the previous semantics, which were unclear and not necessary related to the actual ordering of the message parts.
2009-12-31 16:17:40 +01:00
show: Allow formatters to return errors Formatter errors are propagated to the exit status of notmuch show. This isn't used by the JSON or text formatters, but it will be useful for the raw format, which is pickier.
2012-03-06 19:48:39 +01:00
return res != NOTMUCH_STATUS_SUCCESS;
notmuch: Break notmuch.c up into several smaller files. Now that the client sources are alone here in their own directory, (with all the library sources down inside the lib directory), we can break the client up into multiple files without mixing the files up. The hope is that these smaller files will be easier to manage and maintain.
2009-11-10 21:03:05 +01:00
}
notmuch: Add a 'part' subcommand A new 'part' subcommand allows the user to extract a single part from a MIME message. Usage: notmuch part --part=<n> <search terms> The search terms must match only a single message (e.g. id:foo@bar.com). The part number specified refers to the part identifiers output by `notmuch show'. The content of the part is written the stdout with no formatting or identification marks. It is not JSON formatted.
2010-03-24 08:21:20 +01:00
cli: convert "notmuch show" to use the new argument parser Use the new notmuch argument parser to handle arguments in "notmuch show". There are three minor functional changes: 1) Also set params.raw = TRUE when defaulting to raw format when part is requested but format is not specified. This was a bug, and --part=0 without --format=raw did not work previously. 2) Set params.decrypt = FALSE if crypto context creation fails. 3) Only use the parameters for the last --format if specified multiple times. Previously this could have resulted in a non-working mixture of parameters. Signed-off-by: Jani Nikula <jani@nikula.org>
2012-02-06 20:57:22 +01:00
enum {
NOTMUCH_FORMAT_NOT_SPECIFIED,
NOTMUCH_FORMAT_JSON,
Use the S-Expression structured printer in notmuch-show, notmuch-reply and notmuch-search. This patch uses the new S-Expression printer in the notmuch CLI (show, search and reply). You can now use --format=sexp for any of them.
2012-12-06 22:12:13 +01:00
NOTMUCH_FORMAT_SEXP,
cli: convert "notmuch show" to use the new argument parser Use the new notmuch argument parser to handle arguments in "notmuch show". There are three minor functional changes: 1) Also set params.raw = TRUE when defaulting to raw format when part is requested but format is not specified. This was a bug, and --part=0 without --format=raw did not work previously. 2) Set params.decrypt = FALSE if crypto context creation fails. 3) Only use the parameters for the last --format if specified multiple times. Previously this could have resulted in a non-working mixture of parameters. Signed-off-by: Jani Nikula <jani@nikula.org>
2012-02-06 20:57:22 +01:00
NOTMUCH_FORMAT_TEXT,
NOTMUCH_FORMAT_MBOX,
NOTMUCH_FORMAT_RAW
};
cli: make --entire-thread=false work for format=json. The --entire-thread option in notmuch-show.c defaults to true when format=json. Previously there was no way to turn this off. This patch makes it respect --entire-thread=false. To do this the patch moves the --entire-thread option to be a keyword option using the new command line parsing to allow the existing --entire-thread to keep working.
2012-06-16 12:21:44 +02:00
enum {
ENTIRE_THREAD_DEFAULT,
ENTIRE_THREAD_TRUE,
ENTIRE_THREAD_FALSE,
};
cli: move show to the new --exclude= option naming scheme. This moves notmuch show to the --exclude=(true|false) naming scheme. When exclude=false show returns all threads that match including those that only match in an excluded message. The excluded messages are flagged. When exclude=true the behaviour depends on whether --entire-thread is set. If it is not set then show only returns the messages which match and are not excluded. If it is set then show returns all messages in the threads that match in a non-excluded message, flagging the excluded messages in these threads. The rationale is that it is awkward to use a thread with some missing messages.
2012-04-07 18:10:06 +02:00
/* The following is to allow future options to be added more easily */
enum {
EXCLUDE_TRUE,
EXCLUDE_FALSE,
};
Add 'cat' subcommand This command outputs a raw message matched by search term to the standard output. It allows MUAs to access the messages for piping, attachment manipulation, etc. by running notmuch cat rather then directly access the file. This will simplify the MUAs when they need to operate on a remote database. Edited-by: Carl Worth <cworth@cworth.org>: Remove trailing whitespace, add missing "test_done" to new test script to avoid "Unexpected exit" error.
2010-10-22 11:28:03 +02:00
int
cli: move config open/close to main() from subcommands This allows specifying config file as a top level argument to notmuch, and generally makes it possible to override config file options in main(), without having to touch the subcommands. If the config file does not exist, one will be created for the notmuch main command and setup and help subcommands. Help is special in this regard; the config is created just to avoid errors about missing config, but it will not be saved. This also makes notmuch config the talloc context for subcommands.
2013-03-03 22:55:09 +01:00
notmuch_show_command (notmuch_config_t *config, int argc, char *argv[])
Add 'cat' subcommand This command outputs a raw message matched by search term to the standard output. It allows MUAs to access the messages for piping, attachment manipulation, etc. by running notmuch cat rather then directly access the file. This will simplify the MUAs when they need to operate on a remote database. Edited-by: Carl Worth <cworth@cworth.org>: Remove trailing whitespace, add missing "test_done" to new test script to avoid "Unexpected exit" error.
2010-10-22 11:28:03 +02:00
{
notmuch_database_t *notmuch;
notmuch_query_t *query;
char *query_string;
cli: reach previously unreachable cleanup code in "notmuch show" The last lines of notmuch_show_command() function were unreachable. Fix it by using a variable for return value. Signed-off-by: Jani Nikula <jani@nikula.org>
2012-02-06 20:57:23 +01:00
int opt_index, ret;
pass entire format structure to various show_message functions Various show_message* functions require formatting functions, which were previously being passed individually as arguments. Since we will need to be needing to passing in more formatting function in the future (ie. for crypto support), we here modify things so that we just pass in the entire format structure. This will make things much simpler down the line as we need to pass in new format functions. We move the show_format structure into notmuch-client.c as notmuch_show_format. This also affects notmuch-reply.c, so we create a mostly-empty format_reply to pass the reply_part function to show_message_body.
2011-05-20 20:45:33 +02:00
const notmuch_show_format_t *format = &format_text;
show: Associate an sprinter with each format This associates an sprinter constructor with each show format and uses this to construct the appropriate sprinter. Currently nothing is done with this sprinter, but the following patches will weave it through the layers of notmuch show.
2012-08-03 03:14:50 +02:00
sprinter_t *sprinter;
cli: modify show and reply to use new crypto struct notmuch_show_params_t is modified to use the new notmuch_crypto_t, and notmuch-show and notmuch-reply are modified accordingly.
2012-05-26 20:45:42 +02:00
notmuch_show_params_t params = {
.part = -1,
.omit_excluded = TRUE,
cli: add --body=true|false option to notmuch-show.c This option allows the caller to suppress the output of the bodies of the messages. Currently this is only implemented for format=json. This is used by notmuch-pick.el (although not needed) because it gives a speed-up of at least a factor of a two (and in some cases a speed up of more than a factor of 8); moreover it reduces the memory usage in emacs hugely.
2012-07-24 20:23:27 +02:00
.output_body = TRUE,
cli: modify show and reply to use new crypto struct notmuch_show_params_t is modified to use the new notmuch_crypto_t, and notmuch-show and notmuch-reply are modified accordingly.
2012-05-26 20:45:42 +02:00
.crypto = {
cli: new crypto verify flag to handle verification Use this flag rather than depend on the existence of an initialized gpgctx, to determine whether we should verify a multipart/signed. We will be moving to create the ctx lazily, so we don't want to depend on it being previously initialized if it's not needed.
2012-05-26 20:45:45 +02:00
.verify = FALSE,
CLI: set up infrastructure to make path to gpg configurable. GMIME takes a path to gpg, but we hardcode that path. In this commit we set up argument passing and option storage to allow this path to specified in the top level notmuch command.
2014-12-09 21:01:10 +01:00
.decrypt = FALSE,
.gpgpath = NULL
cli: add --include-html option to notmuch show For my client, the largest bottleneck for displaying large threads is exporting each html part individually since by default notmuch will not show the json parts. For large threads there can be quite a few parts and each must be exported and decoded one by one. Also, I then have to deal with all the crazy charsets which I can do through a library but is a pain. Therefore, this patch adds an --include-html option that causes the text/html parts to be included as part of the output of show. diff man/man1/notmuch-show.1
2013-07-02 02:19:42 +02:00
},
.include_html = FALSE
cli: modify show and reply to use new crypto struct notmuch_show_params_t is modified to use the new notmuch_crypto_t, and notmuch-show and notmuch-reply are modified accordingly.
2012-05-26 20:45:42 +02:00
};
cli: convert "notmuch show" to use the new argument parser Use the new notmuch argument parser to handle arguments in "notmuch show". There are three minor functional changes: 1) Also set params.raw = TRUE when defaulting to raw format when part is requested but format is not specified. This was a bug, and --part=0 without --format=raw did not work previously. 2) Set params.decrypt = FALSE if crypto context creation fails. 3) Only use the parameters for the last --format if specified multiple times. Previously this could have resulted in a non-working mixture of parameters. Signed-off-by: Jani Nikula <jani@nikula.org>
2012-02-06 20:57:22 +01:00
int format_sel = NOTMUCH_FORMAT_NOT_SPECIFIED;
cli: move show to the new --exclude= option naming scheme. This moves notmuch show to the --exclude=(true|false) naming scheme. When exclude=false show returns all threads that match including those that only match in an excluded message. The excluded messages are flagged. When exclude=true the behaviour depends on whether --entire-thread is set. If it is not set then show only returns the messages which match and are not excluded. If it is set then show returns all messages in the threads that match in a non-excluded message, flagging the excluded messages in these threads. The rationale is that it is awkward to use a thread with some missing messages.
2012-04-07 18:10:06 +02:00
int exclude = EXCLUDE_TRUE;
cli: make --entire-thread=false work for format=json. The --entire-thread option in notmuch-show.c defaults to true when format=json. Previously there was no way to turn this off. This patch makes it respect --entire-thread=false. To do this the patch moves the --entire-thread option to be a keyword option using the new command line parsing to allow the existing --entire-thread to keep working.
2012-06-16 12:21:44 +02:00
int entire_thread = ENTIRE_THREAD_DEFAULT;
cli: convert "notmuch show" to use the new argument parser Use the new notmuch argument parser to handle arguments in "notmuch show". There are three minor functional changes: 1) Also set params.raw = TRUE when defaulting to raw format when part is requested but format is not specified. This was a bug, and --part=0 without --format=raw did not work previously. 2) Set params.decrypt = FALSE if crypto context creation fails. 3) Only use the parameters for the last --format if specified multiple times. Previously this could have resulted in a non-working mixture of parameters. Signed-off-by: Jani Nikula <jani@nikula.org>
2012-02-06 20:57:22 +01:00
notmuch_opt_desc_t options[] = {
{ NOTMUCH_OPT_KEYWORD, &format_sel, "format", 'f',
(notmuch_keyword_t []){ { "json", NOTMUCH_FORMAT_JSON },
{ "text", NOTMUCH_FORMAT_TEXT },
Use the S-Expression structured printer in notmuch-show, notmuch-reply and notmuch-search. This patch uses the new S-Expression printer in the notmuch CLI (show, search and reply). You can now use --format=sexp for any of them.
2012-12-06 22:12:13 +01:00
{ "sexp", NOTMUCH_FORMAT_SEXP },
cli: convert "notmuch show" to use the new argument parser Use the new notmuch argument parser to handle arguments in "notmuch show". There are three minor functional changes: 1) Also set params.raw = TRUE when defaulting to raw format when part is requested but format is not specified. This was a bug, and --part=0 without --format=raw did not work previously. 2) Set params.decrypt = FALSE if crypto context creation fails. 3) Only use the parameters for the last --format if specified multiple times. Previously this could have resulted in a non-working mixture of parameters. Signed-off-by: Jani Nikula <jani@nikula.org>
2012-02-06 20:57:22 +01:00
{ "mbox", NOTMUCH_FORMAT_MBOX },
{ "raw", NOTMUCH_FORMAT_RAW },
{ 0, 0 } } },
show: Support --format-version
2012-12-16 04:17:25 +01:00
{ NOTMUCH_OPT_INT, &notmuch_format_version, "format-version", 0, 0 },
cli: notmuch-show.c fix whitespace error Fix an existing whitespace error since it is right next to the changes of this series.
2012-06-16 12:21:47 +02:00
{ NOTMUCH_OPT_KEYWORD, &exclude, "exclude", 'x',
(notmuch_keyword_t []){ { "true", EXCLUDE_TRUE },
{ "false", EXCLUDE_FALSE },
{ 0, 0 } } },
cli: make --entire-thread=false work for format=json. The --entire-thread option in notmuch-show.c defaults to true when format=json. Previously there was no way to turn this off. This patch makes it respect --entire-thread=false. To do this the patch moves the --entire-thread option to be a keyword option using the new command line parsing to allow the existing --entire-thread to keep working.
2012-06-16 12:21:44 +02:00
{ NOTMUCH_OPT_KEYWORD, &entire_thread, "entire-thread", 't',
(notmuch_keyword_t []){ { "true", ENTIRE_THREAD_TRUE },
{ "false", ENTIRE_THREAD_FALSE },
{ "", ENTIRE_THREAD_TRUE },
{ 0, 0 } } },
cli: convert "notmuch show" to use the new argument parser Use the new notmuch argument parser to handle arguments in "notmuch show". There are three minor functional changes: 1) Also set params.raw = TRUE when defaulting to raw format when part is requested but format is not specified. This was a bug, and --part=0 without --format=raw did not work previously. 2) Set params.decrypt = FALSE if crypto context creation fails. 3) Only use the parameters for the last --format if specified multiple times. Previously this could have resulted in a non-working mixture of parameters. Signed-off-by: Jani Nikula <jani@nikula.org>
2012-02-06 20:57:22 +01:00
{ NOTMUCH_OPT_INT, &params.part, "part", 'p', 0 },
cli: modify show and reply to use new crypto struct notmuch_show_params_t is modified to use the new notmuch_crypto_t, and notmuch-show and notmuch-reply are modified accordingly.
2012-05-26 20:45:42 +02:00
{ NOTMUCH_OPT_BOOLEAN, &params.crypto.decrypt, "decrypt", 'd', 0 },
cli: new crypto verify flag to handle verification Use this flag rather than depend on the existence of an initialized gpgctx, to determine whether we should verify a multipart/signed. We will be moving to create the ctx lazily, so we don't want to depend on it being previously initialized if it's not needed.
2012-05-26 20:45:45 +02:00
{ NOTMUCH_OPT_BOOLEAN, &params.crypto.verify, "verify", 'v', 0 },
cli: add --body=true|false option to notmuch-show.c This option allows the caller to suppress the output of the bodies of the messages. Currently this is only implemented for format=json. This is used by notmuch-pick.el (although not needed) because it gives a speed-up of at least a factor of a two (and in some cases a speed up of more than a factor of 8); moreover it reduces the memory usage in emacs hugely.
2012-07-24 20:23:27 +02:00
{ NOTMUCH_OPT_BOOLEAN, &params.output_body, "body", 'b', 0 },
cli: add --include-html option to notmuch show For my client, the largest bottleneck for displaying large threads is exporting each html part individually since by default notmuch will not show the json parts. For large threads there can be quite a few parts and each must be exported and decoded one by one. Also, I then have to deal with all the crazy charsets which I can do through a library but is a pain. Therefore, this patch adds an --include-html option that causes the text/html parts to be included as part of the output of show. diff man/man1/notmuch-show.1
2013-07-02 02:19:42 +02:00
{ NOTMUCH_OPT_BOOLEAN, &params.include_html, "include-html", 0, 0 },
cli: define shared options, use for --help and --version Unfortunately it seems trickier to support --config globally The non-trivial changes are in notmuch.c; most of the other changes consists of blindly inserting two lines into every subcommand.
2015-04-05 15:13:03 +02:00
{ NOTMUCH_OPT_INHERIT, (void *) &notmuch_shared_options, NULL, 0, 0 },
cli: convert "notmuch show" to use the new argument parser Use the new notmuch argument parser to handle arguments in "notmuch show". There are three minor functional changes: 1) Also set params.raw = TRUE when defaulting to raw format when part is requested but format is not specified. This was a bug, and --part=0 without --format=raw did not work previously. 2) Set params.decrypt = FALSE if crypto context creation fails. 3) Only use the parameters for the last --format if specified multiple times. Previously this could have resulted in a non-working mixture of parameters. Signed-off-by: Jani Nikula <jani@nikula.org>
2012-02-06 20:57:22 +01:00
{ 0, 0, 0, 0, 0 }
};
Add 'cat' subcommand This command outputs a raw message matched by search term to the standard output. It allows MUAs to access the messages for piping, attachment manipulation, etc. by running notmuch cat rather then directly access the file. This will simplify the MUAs when they need to operate on a remote database. Edited-by: Carl Worth <cworth@cworth.org>: Remove trailing whitespace, add missing "test_done" to new test script to avoid "Unexpected exit" error.
2010-10-22 11:28:03 +02:00
cli: convert "notmuch show" to use the new argument parser Use the new notmuch argument parser to handle arguments in "notmuch show". There are three minor functional changes: 1) Also set params.raw = TRUE when defaulting to raw format when part is requested but format is not specified. This was a bug, and --part=0 without --format=raw did not work previously. 2) Set params.decrypt = FALSE if crypto context creation fails. 3) Only use the parameters for the last --format if specified multiple times. Previously this could have resulted in a non-working mixture of parameters. Signed-off-by: Jani Nikula <jani@nikula.org>
2012-02-06 20:57:22 +01:00
opt_index = parse_arguments (argc, argv, options, 1);
cli: clean up exit status code returned by the cli commands Apart from the status codes for format mismatches, the non-zero exit status codes have been arbitrary. Make the cli consistently return either EXIT_SUCCESS or EXIT_FAILURE.
2014-01-10 22:28:53 +01:00
if (opt_index < 0)
return EXIT_FAILURE;
create notmuch_show_params_t structure for holding parameters passed to show functions. This simplifies the passing of arguments to the show functions. This will be very useful as we accumulate more parameters that will need to be passed. Currently only the entire_thread parameter is passed this way.
2011-05-21 00:01:52 +02:00
cli: define shared options, use for --help and --version Unfortunately it seems trickier to support --config globally The non-trivial changes are in notmuch.c; most of the other changes consists of blindly inserting two lines into every subcommand.
2015-04-05 15:13:03 +02:00
notmuch_process_shared_options (argv[0]);
cli: new crypto verify flag to handle verification Use this flag rather than depend on the existence of an initialized gpgctx, to determine whether we should verify a multipart/signed. We will be moving to create the ctx lazily, so we don't want to depend on it being previously initialized if it's not needed.
2012-05-26 20:45:45 +02:00
/* decryption implies verification */
if (params.crypto.decrypt)
params.crypto.verify = TRUE;
cli: convert "notmuch show" to use the new argument parser Use the new notmuch argument parser to handle arguments in "notmuch show". There are three minor functional changes: 1) Also set params.raw = TRUE when defaulting to raw format when part is requested but format is not specified. This was a bug, and --part=0 without --format=raw did not work previously. 2) Set params.decrypt = FALSE if crypto context creation fails. 3) Only use the parameters for the last --format if specified multiple times. Previously this could have resulted in a non-working mixture of parameters. Signed-off-by: Jani Nikula <jani@nikula.org>
2012-02-06 20:57:22 +01:00
if (format_sel == NOTMUCH_FORMAT_NOT_SPECIFIED) {
/* if part was requested and format was not specified, use format=raw */
if (params.part >= 0)
format_sel = NOTMUCH_FORMAT_RAW;
else
format_sel = NOTMUCH_FORMAT_TEXT;
}
cli: change argument parsing convention for subcommands previously we deleted the subcommand name from argv before passing to the subcommand. In this version, the deletion is done in the actual subcommands. Although this causes some duplication of code, it allows us to be more flexible about how we parse command line arguments in the subcommand, including possibly using off-the-shelf routines like getopt_long that expect the name of the command in argv[0].
2011-10-21 14:19:17 +02:00
cli: convert "notmuch show" to use the new argument parser Use the new notmuch argument parser to handle arguments in "notmuch show". There are three minor functional changes: 1) Also set params.raw = TRUE when defaulting to raw format when part is requested but format is not specified. This was a bug, and --part=0 without --format=raw did not work previously. 2) Set params.decrypt = FALSE if crypto context creation fails. 3) Only use the parameters for the last --format if specified multiple times. Previously this could have resulted in a non-working mixture of parameters. Signed-off-by: Jani Nikula <jani@nikula.org>
2012-02-06 20:57:22 +01:00
switch (format_sel) {
case NOTMUCH_FORMAT_JSON:
format = &format_json;
break;
case NOTMUCH_FORMAT_TEXT:
format = &format_text;
break;
Use the S-Expression structured printer in notmuch-show, notmuch-reply and notmuch-search. This patch uses the new S-Expression printer in the notmuch CLI (show, search and reply). You can now use --format=sexp for any of them.
2012-12-06 22:12:13 +01:00
case NOTMUCH_FORMAT_SEXP:
format = &format_sexp;
break;
cli: convert "notmuch show" to use the new argument parser Use the new notmuch argument parser to handle arguments in "notmuch show". There are three minor functional changes: 1) Also set params.raw = TRUE when defaulting to raw format when part is requested but format is not specified. This was a bug, and --part=0 without --format=raw did not work previously. 2) Set params.decrypt = FALSE if crypto context creation fails. 3) Only use the parameters for the last --format if specified multiple times. Previously this could have resulted in a non-working mixture of parameters. Signed-off-by: Jani Nikula <jani@nikula.org>
2012-02-06 20:57:22 +01:00
case NOTMUCH_FORMAT_MBOX:
if (params.part > 0) {
fprintf (stderr, "Error: specifying parts is incompatible with mbox output format.\n");
cli: clean up exit status code returned by the cli commands Apart from the status codes for format mismatches, the non-zero exit status codes have been arbitrary. Make the cli consistently return either EXIT_SUCCESS or EXIT_FAILURE.
2014-01-10 22:28:53 +01:00
return EXIT_FAILURE;
Rename "notmuch cat" to "notmuch show --format=raw" This is part of an effort to avoid proliferation of excessive top-level notmuch commands. Also, "raw" better captures the functionality here, (as opposed to "cat" which is a fairly oblique reference to a bad Unix abbreviation whose metaphor doesn't work here since "notmuch cat" operates only on a single message and hence cannot "con'cat'enate" anything).
2010-11-06 20:03:51 +01:00
}
cli: omit excluded messages in results where appropriate. In all cases of notmuch count/search/show where the results returned cannot reflect the exclude flag return just the matched not-excluded results. If the caller wishes to have all the matched results (i.e., including the excluded ones) they should call with the --no-exclude option. The relevant cases are count: both threads and messages search: all cases except the summary view show: mbox format
2012-03-01 23:30:43 +01:00
cli: convert "notmuch show" to use the new argument parser Use the new notmuch argument parser to handle arguments in "notmuch show". There are three minor functional changes: 1) Also set params.raw = TRUE when defaulting to raw format when part is requested but format is not specified. This was a bug, and --part=0 without --format=raw did not work previously. 2) Set params.decrypt = FALSE if crypto context creation fails. 3) Only use the parameters for the last --format if specified multiple times. Previously this could have resulted in a non-working mixture of parameters. Signed-off-by: Jani Nikula <jani@nikula.org>
2012-02-06 20:57:22 +01:00
format = &format_mbox;
break;
case NOTMUCH_FORMAT_RAW:
format = &format_raw;
/* If --format=raw specified without specifying part, we can only
* output single message, so set part=0 */
if (params.part < 0)
params.part = 0;
params.raw = TRUE;
break;
}
show: Support --format-version
2012-12-16 04:17:25 +01:00
notmuch_exit_if_unsupported_format ();
Use the S-Expression structured printer in notmuch-show, notmuch-reply and notmuch-search. This patch uses the new S-Expression printer in the notmuch CLI (show, search and reply). You can now use --format=sexp for any of them.
2012-12-06 22:12:13 +01:00
/* Default is entire-thread = FALSE except for format=json and
* format=sexp. */
cli: make --entire-thread=false work for format=json. The --entire-thread option in notmuch-show.c defaults to true when format=json. Previously there was no way to turn this off. This patch makes it respect --entire-thread=false. To do this the patch moves the --entire-thread option to be a keyword option using the new command line parsing to allow the existing --entire-thread to keep working.
2012-06-16 12:21:44 +02:00
if (entire_thread == ENTIRE_THREAD_DEFAULT) {
Use the S-Expression structured printer in notmuch-show, notmuch-reply and notmuch-search. This patch uses the new S-Expression printer in the notmuch CLI (show, search and reply). You can now use --format=sexp for any of them.
2012-12-06 22:12:13 +01:00
if (format == &format_json || format == &format_sexp)
cli: make --entire-thread=false work for format=json. The --entire-thread option in notmuch-show.c defaults to true when format=json. Previously there was no way to turn this off. This patch makes it respect --entire-thread=false. To do this the patch moves the --entire-thread option to be a keyword option using the new command line parsing to allow the existing --entire-thread to keep working.
2012-06-16 12:21:44 +02:00
entire_thread = ENTIRE_THREAD_TRUE;
else
entire_thread = ENTIRE_THREAD_FALSE;
}
cli: add --body=true|false option to notmuch-show.c This option allows the caller to suppress the output of the bodies of the messages. Currently this is only implemented for format=json. This is used by notmuch-pick.el (although not needed) because it gives a speed-up of at least a factor of a two (and in some cases a speed up of more than a factor of 8); moreover it reduces the memory usage in emacs hugely.
2012-07-24 20:23:27 +02:00
if (!params.output_body) {
if (params.part > 0) {
fprintf (stderr, "Warning: --body=false is incompatible with --part > 0. Disabling.\n");
params.output_body = TRUE;
} else {
Use the S-Expression structured printer in notmuch-show, notmuch-reply and notmuch-search. This patch uses the new S-Expression printer in the notmuch CLI (show, search and reply). You can now use --format=sexp for any of them.
2012-12-06 22:12:13 +01:00
if (format != &format_json && format != &format_sexp)
fprintf (stderr,
"Warning: --body=false only implemented for format=json and format=sexp\n");
cli: add --body=true|false option to notmuch-show.c This option allows the caller to suppress the output of the bodies of the messages. Currently this is only implemented for format=json. This is used by notmuch-pick.el (although not needed) because it gives a speed-up of at least a factor of a two (and in some cases a speed up of more than a factor of 8); moreover it reduces the memory usage in emacs hugely.
2012-07-24 20:23:27 +02:00
}
}
cli: add --include-html option to notmuch show For my client, the largest bottleneck for displaying large threads is exporting each html part individually since by default notmuch will not show the json parts. For large threads there can be quite a few parts and each must be exported and decoded one by one. Also, I then have to deal with all the crazy charsets which I can do through a library but is a pain. Therefore, this patch adds an --include-html option that causes the text/html parts to be included as part of the output of show. diff man/man1/notmuch-show.1
2013-07-02 02:19:42 +02:00
if (params.include_html &&
(format_sel != NOTMUCH_FORMAT_JSON && format_sel != NOTMUCH_FORMAT_SEXP)) {
fprintf (stderr, "Warning: --include-html only implemented for format=json and format=sexp\n");
}
cli: make --entire-thread=false work for format=json. The --entire-thread option in notmuch-show.c defaults to true when format=json. Previously there was no way to turn this off. This patch makes it respect --entire-thread=false. To do this the patch moves the --entire-thread option to be a keyword option using the new command line parsing to allow the existing --entire-thread to keep working.
2012-06-16 12:21:44 +02:00
if (entire_thread == ENTIRE_THREAD_TRUE)
params.entire_thread = TRUE;
else
params.entire_thread = FALSE;
cli: move config open/close to main() from subcommands This allows specifying config file as a top level argument to notmuch, and generally makes it possible to override config file options in main(), without having to touch the subcommands. If the config file does not exist, one will be created for the notmuch main command and setup and help subcommands. Help is special in this regard; the config is created just to avoid errors about missing config, but it will not be saved. This also makes notmuch config the talloc context for subcommands.
2013-03-03 22:55:09 +01:00
query_string = query_string_from_args (config, argc-opt_index, argv+opt_index);
Add 'cat' subcommand This command outputs a raw message matched by search term to the standard output. It allows MUAs to access the messages for piping, attachment manipulation, etc. by running notmuch cat rather then directly access the file. This will simplify the MUAs when they need to operate on a remote database. Edited-by: Carl Worth <cworth@cworth.org>: Remove trailing whitespace, add missing "test_done" to new test script to avoid "Unexpected exit" error.
2010-10-22 11:28:03 +02:00
if (query_string == NULL) {
fprintf (stderr, "Out of memory\n");
cli: clean up exit status code returned by the cli commands Apart from the status codes for format mismatches, the non-zero exit status codes have been arbitrary. Make the cli consistently return either EXIT_SUCCESS or EXIT_FAILURE.
2014-01-10 22:28:53 +01:00
return EXIT_FAILURE;
Add 'cat' subcommand This command outputs a raw message matched by search term to the standard output. It allows MUAs to access the messages for piping, attachment manipulation, etc. by running notmuch cat rather then directly access the file. This will simplify the MUAs when they need to operate on a remote database. Edited-by: Carl Worth <cworth@cworth.org>: Remove trailing whitespace, add missing "test_done" to new test script to avoid "Unexpected exit" error.
2010-10-22 11:28:03 +02:00
}
if (*query_string == '\0') {
Rename "notmuch cat" to "notmuch show --format=raw" This is part of an effort to avoid proliferation of excessive top-level notmuch commands. Also, "raw" better captures the functionality here, (as opposed to "cat" which is a fairly oblique reference to a bad Unix abbreviation whose metaphor doesn't work here since "notmuch cat" operates only on a single message and hence cannot "con'cat'enate" anything).
2010-11-06 20:03:51 +01:00
fprintf (stderr, "Error: notmuch show requires at least one search term.\n");
cli: clean up exit status code returned by the cli commands Apart from the status codes for format mismatches, the non-zero exit status codes have been arbitrary. Make the cli consistently return either EXIT_SUCCESS or EXIT_FAILURE.
2014-01-10 22:28:53 +01:00
return EXIT_FAILURE;
Add 'cat' subcommand This command outputs a raw message matched by search term to the standard output. It allows MUAs to access the messages for piping, attachment manipulation, etc. by running notmuch cat rather then directly access the file. This will simplify the MUAs when they need to operate on a remote database. Edited-by: Carl Worth <cworth@cworth.org>: Remove trailing whitespace, add missing "test_done" to new test script to avoid "Unexpected exit" error.
2010-10-22 11:28:03 +02:00
}
CLI: make gpg binary used by libgmime configurable. Previously we set up a way for the top level notmuch command to choose which gpg binary was invoked by libgmime. In this commit we add the (mostly boilerplate) code to allow the notmuch-config command to read and write this path, and use it in the appropriate struct. Update tests for new default variable
2014-12-09 21:01:11 +01:00
params.crypto.gpgpath = notmuch_config_get_crypto_gpg_path (config);
lib/cli: Make notmuch_database_open return a status code It has been a long-standing issue that notmuch_database_open doesn't return any indication of why it failed. This patch changes its prototype to return a notmuch_status_t and set an out-argument to the database itself, like other functions that return both a status and an object. In the interest of atomicity, this also updates every use in the CLI so that notmuch still compiles. Since this patch does not update the bindings, the Python bindings test fails.
2012-04-30 18:25:33 +02:00
if (notmuch_database_open (notmuch_config_get_database_path (config),
NOTMUCH_DATABASE_MODE_READ_ONLY, &notmuch))
cli: clean up exit status code returned by the cli commands Apart from the status codes for format mismatches, the non-zero exit status codes have been arbitrary. Make the cli consistently return either EXIT_SUCCESS or EXIT_FAILURE.
2014-01-10 22:28:53 +01:00
return EXIT_FAILURE;
Add 'cat' subcommand This command outputs a raw message matched by search term to the standard output. It allows MUAs to access the messages for piping, attachment manipulation, etc. by running notmuch cat rather then directly access the file. This will simplify the MUAs when they need to operate on a remote database. Edited-by: Carl Worth <cworth@cworth.org>: Remove trailing whitespace, add missing "test_done" to new test script to avoid "Unexpected exit" error.
2010-10-22 11:28:03 +02:00
cli: add global option "--uuid" The function notmuch_exit_if_unmatched_db_uuid is split from notmuch_process_shared_options because it needs an open notmuch database. There are two exceptional cases in uuid handling. 1) notmuch config and notmuch setup don't currently open the database, so it doesn't make sense to check the UUID. 2) notmuch compact opens the database inside the library, so we either need to open the database just to check uuid, or change the API.
2015-04-06 00:39:55 +02:00
notmuch_exit_if_unmatched_db_uuid (notmuch);
Add 'cat' subcommand This command outputs a raw message matched by search term to the standard output. It allows MUAs to access the messages for piping, attachment manipulation, etc. by running notmuch cat rather then directly access the file. This will simplify the MUAs when they need to operate on a remote database. Edited-by: Carl Worth <cworth@cworth.org>: Remove trailing whitespace, add missing "test_done" to new test script to avoid "Unexpected exit" error.
2010-10-22 11:28:03 +02:00
query = notmuch_query_create (notmuch, query_string);
if (query == NULL) {
Rename "notmuch cat" to "notmuch show --format=raw" This is part of an effort to avoid proliferation of excessive top-level notmuch commands. Also, "raw" better captures the functionality here, (as opposed to "cat" which is a fairly oblique reference to a bad Unix abbreviation whose metaphor doesn't work here since "notmuch cat" operates only on a single message and hence cannot "con'cat'enate" anything).
2010-11-06 20:03:51 +01:00
fprintf (stderr, "Out of memory\n");
cli: clean up exit status code returned by the cli commands Apart from the status codes for format mismatches, the non-zero exit status codes have been arbitrary. Make the cli consistently return either EXIT_SUCCESS or EXIT_FAILURE.
2014-01-10 22:28:53 +01:00
return EXIT_FAILURE;
Add 'cat' subcommand This command outputs a raw message matched by search term to the standard output. It allows MUAs to access the messages for piping, attachment manipulation, etc. by running notmuch cat rather then directly access the file. This will simplify the MUAs when they need to operate on a remote database. Edited-by: Carl Worth <cworth@cworth.org>: Remove trailing whitespace, add missing "test_done" to new test script to avoid "Unexpected exit" error.
2010-10-22 11:28:03 +02:00
}
show: Associate an sprinter with each format This associates an sprinter constructor with each show format and uses this to construct the appropriate sprinter. Currently nothing is done with this sprinter, but the following patches will weave it through the layers of notmuch show.
2012-08-03 03:14:50 +02:00
/* Create structure printer. */
cli: move config open/close to main() from subcommands This allows specifying config file as a top level argument to notmuch, and generally makes it possible to override config file options in main(), without having to touch the subcommands. If the config file does not exist, one will be created for the notmuch main command and setup and help subcommands. Help is special in this regard; the config is created just to avoid errors about missing config, but it will not be saved. This also makes notmuch config the talloc context for subcommands.
2013-03-03 22:55:09 +01:00
sprinter = format->new_sprinter(config, stdout);
show: Associate an sprinter with each format This associates an sprinter constructor with each show format and uses this to construct the appropriate sprinter. Currently nothing is done with this sprinter, but the following patches will weave it through the layers of notmuch show.
2012-08-03 03:14:50 +02:00
cli: Make notmuch-show respect excludes. This adds the excludes to notmuch-show.c. We do not exclude when only a single message (or part) is requested. notmuch-show will output the exclude information when either text or json format is requested. As this changes the output from notmuch-show it breaks many tests (in a trivial and expected fashion).
2012-03-01 23:30:40 +01:00
/* If a single message is requested we do not use search_excludes. */
New part output handling as option to notmuch-show. Outputting of single MIME parts is moved to an option of notmuch show, instead of being handled in it's own sub-command. The recent rework of multipart mime allowed for this change but consolidating part handling into a single recursive function (show_message_part) that includes formatting. This allows for far simpler handling single output of a single part, including formatting.
2011-05-24 00:31:32 +02:00
if (params.part >= 0)
cli: move config open/close to main() from subcommands This allows specifying config file as a top level argument to notmuch, and generally makes it possible to override config file options in main(), without having to touch the subcommands. If the config file does not exist, one will be created for the notmuch main command and setup and help subcommands. Help is special in this regard; the config is created just to avoid errors about missing config, but it will not be saved. This also makes notmuch config the talloc context for subcommands.
2013-03-03 22:55:09 +01:00
ret = do_show_single (config, query, format, sprinter, &params);
cli: Make notmuch-show respect excludes. This adds the excludes to notmuch-show.c. We do not exclude when only a single message (or part) is requested. notmuch-show will output the exclude information when either text or json format is requested. As this changes the output from notmuch-show it breaks many tests (in a trivial and expected fashion).
2012-03-01 23:30:40 +01:00
else {
cli: move show to the new --exclude= option naming scheme. This moves notmuch show to the --exclude=(true|false) naming scheme. When exclude=false show returns all threads that match including those that only match in an excluded message. The excluded messages are flagged. When exclude=true the behaviour depends on whether --entire-thread is set. If it is not set then show only returns the messages which match and are not excluded. If it is set then show returns all messages in the threads that match in a non-excluded message, flagging the excluded messages in these threads. The rationale is that it is awkward to use a thread with some missing messages.
2012-04-07 18:10:06 +02:00
/* We always apply set the exclude flag. The
* exclude=true|false option controls whether or not we return
* threads that only match in an excluded message */
const char **search_exclude_tags;
size_t search_exclude_tags_length;
unsigned int i;
search_exclude_tags = notmuch_config_get_search_exclude_tags
(config, &search_exclude_tags_length);
for (i = 0; i < search_exclude_tags_length; i++)
notmuch_query_add_tag_exclude (query, search_exclude_tags[i]);
if (exclude == EXCLUDE_FALSE) {
notmuch_query_set_omit_excluded (query, FALSE);
params.omit_excluded = FALSE;
cli: Make notmuch-show respect excludes. This adds the excludes to notmuch-show.c. We do not exclude when only a single message (or part) is requested. notmuch-show will output the exclude information when either text or json format is requested. As this changes the output from notmuch-show it breaks many tests (in a trivial and expected fashion).
2012-03-01 23:30:40 +01:00
}
cli: move show to the new --exclude= option naming scheme. This moves notmuch show to the --exclude=(true|false) naming scheme. When exclude=false show returns all threads that match including those that only match in an excluded message. The excluded messages are flagged. When exclude=true the behaviour depends on whether --entire-thread is set. If it is not set then show only returns the messages which match and are not excluded. If it is set then show returns all messages in the threads that match in a non-excluded message, flagging the excluded messages in these threads. The rationale is that it is awkward to use a thread with some missing messages.
2012-04-07 18:10:06 +02:00
cli: move config open/close to main() from subcommands This allows specifying config file as a top level argument to notmuch, and generally makes it possible to override config file options in main(), without having to touch the subcommands. If the config file does not exist, one will be created for the notmuch main command and setup and help subcommands. Help is special in this regard; the config is created just to avoid errors about missing config, but it will not be saved. This also makes notmuch config the talloc context for subcommands.
2013-03-03 22:55:09 +01:00
ret = do_show (config, query, format, sprinter, &params);
cli: Make notmuch-show respect excludes. This adds the excludes to notmuch-show.c. We do not exclude when only a single message (or part) is requested. notmuch-show will output the exclude information when either text or json format is requested. As this changes the output from notmuch-show it breaks many tests (in a trivial and expected fashion).
2012-03-01 23:30:40 +01:00
}
cli: modify show and reply to use new crypto struct notmuch_show_params_t is modified to use the new notmuch_crypto_t, and notmuch-show and notmuch-reply are modified accordingly.
2012-05-26 20:45:42 +02:00
notmuch_crypto_cleanup (&params.crypto);
Add 'cat' subcommand This command outputs a raw message matched by search term to the standard output. It allows MUAs to access the messages for piping, attachment manipulation, etc. by running notmuch cat rather then directly access the file. This will simplify the MUAs when they need to operate on a remote database. Edited-by: Carl Worth <cworth@cworth.org>: Remove trailing whitespace, add missing "test_done" to new test script to avoid "Unexpected exit" error.
2010-10-22 11:28:03 +02:00
notmuch_query_destroy (query);
Use notmuch_database_destroy instead of notmuch_database_close Adapt the notmuch binaries source to the notmuch_database_close split. Signed-off-by: Justus Winter <4winter@informatik.uni-hamburg.de>
2012-04-22 14:07:53 +02:00
notmuch_database_destroy (notmuch);
Add 'cat' subcommand This command outputs a raw message matched by search term to the standard output. It allows MUAs to access the messages for piping, attachment manipulation, etc. by running notmuch cat rather then directly access the file. This will simplify the MUAs when they need to operate on a remote database. Edited-by: Carl Worth <cworth@cworth.org>: Remove trailing whitespace, add missing "test_done" to new test script to avoid "Unexpected exit" error.
2010-10-22 11:28:03 +02:00
cli: clean up exit status code returned by the cli commands Apart from the status codes for format mismatches, the non-zero exit status codes have been arbitrary. Make the cli consistently return either EXIT_SUCCESS or EXIT_FAILURE.
2014-01-10 22:28:53 +01:00
return ret ? EXIT_FAILURE : EXIT_SUCCESS;
Add 'cat' subcommand This command outputs a raw message matched by search term to the standard output. It allows MUAs to access the messages for piping, attachment manipulation, etc. by running notmuch cat rather then directly access the file. This will simplify the MUAs when they need to operate on a remote database. Edited-by: Carl Worth <cworth@cworth.org>: Remove trailing whitespace, add missing "test_done" to new test script to avoid "Unexpected exit" error.
2010-10-22 11:28:03 +02:00
}
Reference in a new issue Copy permalink