X-Git-Url: https://git.notmuchmail.org/git?p=notmuch;a=blobdiff_plain;f=lib%2Fthread.cc;h=173460084e2ce31cb8e31fc878c0377b1676f9e2;hp=0c937d7697a1007cdb27bd5c18eb7d93dfc38ba8;hb=HEAD;hpb=378ba492a634db5b841f2454991239a897f830b2 diff --git a/lib/thread.cc b/lib/thread.cc index 0c937d76..60e9a666 100644 --- a/lib/thread.cc +++ b/lib/thread.cc @@ -13,7 +13,7 @@ * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License - * along with this program. If not, see http://www.gnu.org/licenses/ . + * along with this program. If not, see https://www.gnu.org/licenses/ . * * Author: Carl Worth */ @@ -22,11 +22,16 @@ #include "database-private.h" #include -#include /* GHashTable */ +#include /* GHashTable */ -#define EMPTY_STRING(s) ((s)[0] == '\0') +#ifdef DEBUG_THREADING +#define THREAD_DEBUG(format, ...) fprintf (stderr, "DT: " format " (%s).\n", ##__VA_ARGS__, \ + __location__) +#else +#define THREAD_DEBUG(format, ...) do {} while (0) /* ignored */ +#endif -struct visible _notmuch_thread { +struct _notmuch_thread { notmuch_database_t *notmuch; char *thread_id; char *subject; @@ -44,6 +49,7 @@ struct visible _notmuch_thread { GHashTable *message_hash; int total_messages; + int total_files; int matched_messages; time_t oldest; time_t newest; @@ -58,12 +64,12 @@ _notmuch_thread_destructor (notmuch_thread_t *thread) g_hash_table_unref (thread->message_hash); if (thread->authors_array) { - g_ptr_array_free (thread->authors_array, TRUE); + g_ptr_array_free (thread->authors_array, true); thread->authors_array = NULL; } if (thread->matched_authors_array) { - g_ptr_array_free (thread->matched_authors_array, TRUE); + g_ptr_array_free (thread->matched_authors_array, true); thread->matched_authors_array = NULL; } @@ -155,10 +161,13 @@ _resolve_thread_authors_string (notmuch_thread_t *thread) first_non_matched_author = 0; } - g_ptr_array_free (thread->authors_array, TRUE); + g_ptr_array_free (thread->authors_array, true); thread->authors_array = NULL; - g_ptr_array_free (thread->matched_authors_array, TRUE); + g_ptr_array_free (thread->matched_authors_array, true); thread->matched_authors_array = NULL; + + if (! thread->authors) + thread->authors = talloc_strdup (thread, ""); } /* clean up the ugly "Lastname, Firstname" format that some mail systems @@ -172,14 +181,14 @@ static char * _thread_cleanup_author (notmuch_thread_t *thread, const char *author, const char *from) { - char *clean_author,*test_author; + char *clean_author, *test_author; const char *comma; char *blank; - int fname,lname; + int fname, lname; if (author == NULL) return NULL; - clean_author = talloc_strdup(thread, author); + clean_author = talloc_strdup (thread, author); if (clean_author == NULL) return NULL; /* check if there's a comma in the name and that there's a @@ -188,34 +197,34 @@ _thread_cleanup_author (notmuch_thread_t *thread, * one character long ",\0"). * Otherwise just return the copy of the original author name that * we just made*/ - comma = strchr(author,','); - if (comma && strlen(comma) > 1) { + comma = strchr (author, ','); + if (comma && strlen (comma) > 1) { /* let's assemble what we think is the correct name */ lname = comma - author; /* Skip all the spaces after the comma */ - fname = strlen(author) - lname - 1; + fname = strlen (author) - lname - 1; comma += 1; while (*comma == ' ') { fname -= 1; comma += 1; } - strncpy(clean_author, comma, fname); + strncpy (clean_author, comma, fname); - *(clean_author+fname) = ' '; - strncpy(clean_author + fname + 1, author, lname); - *(clean_author+fname+1+lname) = '\0'; + *(clean_author + fname) = ' '; + strncpy (clean_author + fname + 1, author, lname); + *(clean_author + fname + 1 + lname) = '\0'; /* make a temporary copy and see if it matches the email */ - test_author = talloc_strdup(thread,clean_author); + test_author = talloc_strdup (thread, clean_author); - blank=strchr(test_author,' '); + blank = strchr (test_author, ' '); while (blank != NULL) { *blank = '.'; - blank=strchr(test_author,' '); + blank = strchr (test_author, ' '); } - if (strcasestr(from, test_author) == NULL) + if (strcasestr (from, test_author) == NULL) /* we didn't identify this as part of the email address - * so let's punt and return the original author */ + * so let's punt and return the original author */ strcpy (clean_author, author); } return clean_author; @@ -238,22 +247,20 @@ _thread_add_message (notmuch_thread_t *thread, InternetAddress *address; const char *from, *author; char *clean_author; - notmuch_bool_t message_excluded = FALSE; + bool message_excluded = false; if (omit_exclude != NOTMUCH_EXCLUDE_FALSE) { for (tags = notmuch_message_get_tags (message); notmuch_tags_valid (tags); - notmuch_tags_move_to_next (tags)) - { + notmuch_tags_move_to_next (tags)) { tag = notmuch_tags_get (tags); /* Is message excluded? */ for (notmuch_string_node_t *term = exclude_terms->head; term != NULL; - term = term->next) - { + term = term->next) { /* Check for an empty string, and then ignore initial 'K'. */ - if (*(term->string) && strcmp(tag, (term->string + 1)) == 0) { - message_excluded = TRUE; + if (*(term->string) && strcmp (tag, (term->string + 1)) == 0) { + message_excluded = true; break; } } @@ -266,6 +273,7 @@ _thread_add_message (notmuch_thread_t *thread, _notmuch_message_list_add_message (thread->message_list, talloc_steal (thread, message)); thread->total_messages++; + thread->total_files += notmuch_message_count_files (message); g_hash_table_insert (thread->message_hash, xstrdup (notmuch_message_get_message_id (message)), @@ -273,7 +281,7 @@ _thread_add_message (notmuch_thread_t *thread, from = notmuch_message_get_header (message, "from"); if (from) - list = internet_address_list_parse_string (from); + list = internet_address_list_parse (NULL, from); if (list) { address = internet_address_list_get_address (list, 0); @@ -300,15 +308,14 @@ _thread_add_message (notmuch_thread_t *thread, for (tags = notmuch_message_get_tags (message); notmuch_tags_valid (tags); - notmuch_tags_move_to_next (tags)) - { + notmuch_tags_move_to_next (tags)) { tag = notmuch_tags_get (tags); g_hash_table_insert (thread->tags, xstrdup (tag), NULL); } /* Mark excluded messages. */ if (message_excluded) - notmuch_message_set_flag (message, NOTMUCH_MESSAGE_FLAG_EXCLUDED, TRUE); + notmuch_message_set_flag (message, NOTMUCH_MESSAGE_FLAG_EXCLUDED, true); } static void @@ -329,12 +336,12 @@ _thread_set_subject_from_message (notmuch_thread_t *thread, cleaned_subject = talloc_strndup (thread, subject + 4, - strlen(subject) - 4); + strlen (subject) - 4); } else { cleaned_subject = talloc_strdup (thread, subject); } - if (! EMPTY_STRING(cleaned_subject)) { + if (! EMPTY_STRING (cleaned_subject)) { if (thread->subject) talloc_free (thread->subject); @@ -345,14 +352,16 @@ _thread_set_subject_from_message (notmuch_thread_t *thread, /* Add a message to this thread which is known to match the original * search specification. The 'sort' parameter controls whether the * oldest or newest matching subject is applied to the thread as a - * whole. */ -static void + * whole. Returns 0 on success. + */ +static int _thread_add_matched_message (notmuch_thread_t *thread, notmuch_message_t *message, notmuch_sort_t sort) { time_t date; notmuch_message_t *hashed_message; + notmuch_bool_t is_set; date = notmuch_message_get_date (message); @@ -364,53 +373,152 @@ _thread_add_matched_message (notmuch_thread_t *thread, if (date > thread->newest || ! thread->matched_messages) { thread->newest = date; - const char *cur_subject = notmuch_thread_get_subject(thread); - if (sort != NOTMUCH_SORT_OLDEST_FIRST || EMPTY_STRING(cur_subject)) + const char *cur_subject = notmuch_thread_get_subject (thread); + if (sort != NOTMUCH_SORT_OLDEST_FIRST || EMPTY_STRING (cur_subject)) _thread_set_subject_from_message (thread, message); } - if (!notmuch_message_get_flag (message, NOTMUCH_MESSAGE_FLAG_EXCLUDED)) + if (notmuch_message_get_flag_st (message, NOTMUCH_MESSAGE_FLAG_EXCLUDED, &is_set)) + return -1; + if (! is_set) thread->matched_messages++; if (g_hash_table_lookup_extended (thread->message_hash, - notmuch_message_get_message_id (message), NULL, - (void **) &hashed_message)) { + notmuch_message_get_message_id (message), NULL, + (void **) &hashed_message)) { notmuch_message_set_flag (hashed_message, NOTMUCH_MESSAGE_FLAG_MATCH, 1); } _thread_add_matched_author (thread, _notmuch_message_get_author (hashed_message)); + return 0; +} + +static bool +_parent_via_in_reply_to (notmuch_thread_t *thread, notmuch_message_t *message) +{ + notmuch_message_t *parent; + const char *in_reply_to; + + in_reply_to = _notmuch_message_get_in_reply_to (message); + THREAD_DEBUG ("checking message = %s in_reply_to=%s", + notmuch_message_get_message_id (message), in_reply_to); + + if (in_reply_to && (! EMPTY_STRING (in_reply_to)) && + g_hash_table_lookup_extended (thread->message_hash, + in_reply_to, NULL, + (void **) &parent)) { + _notmuch_message_add_reply (parent, message); + return true; + } else { + return false; + } +} + +static void +_parent_or_toplevel (notmuch_thread_t *thread, notmuch_message_t *message) +{ + size_t max_depth = 0; + notmuch_message_t *new_parent; + notmuch_message_t *parent = NULL; + const notmuch_string_list_t *references = + _notmuch_message_get_references (message); + + THREAD_DEBUG ("trying to reparent via references: %s", + notmuch_message_get_message_id (message)); + + for (notmuch_string_node_t *ref_node = references->head; + ref_node; ref_node = ref_node->next) { + THREAD_DEBUG ("checking reference=%s", ref_node->string); + if ((g_hash_table_lookup_extended (thread->message_hash, + ref_node->string, NULL, + (void **) &new_parent))) { + size_t new_depth = _notmuch_message_get_thread_depth (new_parent); + THREAD_DEBUG ("got depth %lu", new_depth); + if (new_depth > max_depth || ! parent) { + THREAD_DEBUG ("adding at depth %lu parent=%s", new_depth, ref_node->string); + max_depth = new_depth; + parent = new_parent; + } + } + } + if (parent) { + THREAD_DEBUG ("adding reply %s to parent=%s", + notmuch_message_get_message_id (message), + notmuch_message_get_message_id (parent)); + _notmuch_message_add_reply (parent, message); + } else { + THREAD_DEBUG ("adding as toplevel %s", + notmuch_message_get_message_id (message)); + _notmuch_message_list_add_message (thread->toplevel_list, message); + } } static void _resolve_thread_relationships (notmuch_thread_t *thread) { - notmuch_message_node_t *node; - notmuch_message_t *message, *parent; - const char *in_reply_to; + notmuch_message_node_t *node, *first_node; + notmuch_message_t *message; + void *local; + notmuch_message_list_t *maybe_toplevel_list; + + first_node = thread->message_list->head; + if (! first_node) + return; - for (node = thread->message_list->head; node; node = node->next) { + local = talloc_new (thread); + maybe_toplevel_list = _notmuch_message_list_create (local); + + for (node = first_node->next; node; node = node->next) { message = node->message; - in_reply_to = _notmuch_message_get_in_reply_to (message); - if (in_reply_to && strlen (in_reply_to) && - g_hash_table_lookup_extended (thread->message_hash, - in_reply_to, NULL, - (void **) &parent)) - _notmuch_message_add_reply (parent, message); + if (! _parent_via_in_reply_to (thread, message)) + _notmuch_message_list_add_message (maybe_toplevel_list, message); + } + + /* + * if we reach the end of the list without finding a top-level + * message, that means the thread is a cycle (or set of cycles) + * and any message can be considered top-level. Choose the oldest + * message, which happens to be first in our list. + */ + if (first_node) { + message = first_node->message; + THREAD_DEBUG ("checking first message %s", + notmuch_message_get_message_id (message)); + + if (_notmuch_message_list_empty (maybe_toplevel_list) || + ! _parent_via_in_reply_to (thread, message)) { + + THREAD_DEBUG ("adding first message as toplevel = %s", + notmuch_message_get_message_id (message)); + _notmuch_message_list_add_message (maybe_toplevel_list, message); + } + } + + for (notmuch_messages_t *messages = _notmuch_messages_create (maybe_toplevel_list); + notmuch_messages_valid (messages); + notmuch_messages_move_to_next (messages)) { + notmuch_message_t *message = notmuch_messages_get (messages); + _notmuch_message_label_depths (message, 0); + } + + for (notmuch_messages_t *roots = _notmuch_messages_create (maybe_toplevel_list); + notmuch_messages_valid (roots); + notmuch_messages_move_to_next (roots)) { + notmuch_message_t *message = notmuch_messages_get (roots); + if (_notmuch_messages_has_next (roots) || ! _notmuch_message_list_empty ( + thread->toplevel_list)) + _parent_or_toplevel (thread, message); else _notmuch_message_list_add_message (thread->toplevel_list, message); } - /* XXX: After scanning through the entire list looking for parents - * via "In-Reply-To", we should do a second pass that looks at the - * list of messages IDs in the "References" header instead. (And - * for this the parent would be the "deepest" message of all the - * messages found in the "References" list.) - * - * Doing this will allow messages and sub-threads to be positioned - * correctly in the thread even when an intermediate message is - * missing from the thread. + /* XXX this could be made conditional on messages being inserted + * (out of order) in later passes */ + thread->toplevel_list = _notmuch_message_sort_subtrees (thread, thread->toplevel_list); + + talloc_free (local); } /* Create a new notmuch_thread_t object by finding the thread @@ -495,6 +603,7 @@ _notmuch_thread_create (void *ctx, free, NULL); thread->total_messages = 0; + thread->total_files = 0; thread->matched_messages = 0; thread->oldest = 0; thread->newest = 0; @@ -505,14 +614,13 @@ _notmuch_thread_create (void *ctx, * oldest or newest subject is desired. */ notmuch_query_set_sort (thread_id_query, NOTMUCH_SORT_OLDEST_FIRST); - status = notmuch_query_search_messages_st (thread_id_query, &messages); + status = notmuch_query_search_messages (thread_id_query, &messages); if (status) goto DONE; for (; notmuch_messages_valid (messages); - notmuch_messages_move_to_next (messages)) - { + notmuch_messages_move_to_next (messages)) { unsigned int doc_id; message = notmuch_messages_get (messages); @@ -524,7 +632,10 @@ _notmuch_thread_create (void *ctx, if ( _notmuch_doc_id_set_contains (match_set, doc_id)) { _notmuch_doc_id_set_remove (match_set, doc_id); - _thread_add_matched_message (thread, message, sort); + if (_thread_add_matched_message (thread, message, sort)) { + thread = NULL; + goto DONE; + } } _notmuch_message_close (message); @@ -566,6 +677,12 @@ notmuch_thread_get_total_messages (notmuch_thread_t *thread) return thread->total_messages; } +int +notmuch_thread_get_total_files (notmuch_thread_t *thread) +{ + return thread->total_files; +} + int notmuch_thread_get_matched_messages (notmuch_thread_t *thread) {