X-Git-Url: https://git.notmuchmail.org/git?a=blobdiff_plain;f=lib%2Fthread.cc;h=e1da060e5158f5e1f0d8c4709645de1e6604efad;hb=b66ff567f6b65c7aafa1216294900303ad3aa4d4;hp=ec80f8518b9ebe7856db7a5a78cea474baf53e9f;hpb=4e5d2f22db290a830c0267f34b519c6138af00ed;p=notmuch

diff --git a/lib/thread.cc b/lib/thread.cc
index ec80f851..e1da060e 100644
--- a/lib/thread.cc
+++ b/lib/thread.cc
@@ -84,7 +84,7 @@ _thread_add_message (notmuch_thread_t *thread,
 {
     notmuch_tags_t *tags;
     const char *tag;
-    InternetAddressList *list;
+    InternetAddressList *list = NULL;
     InternetAddress *address;
     const char *from, *author;
 
@@ -97,7 +97,9 @@ _thread_add_message (notmuch_thread_t *thread,
 			 message);
 
     from = notmuch_message_get_header (message, "from");
-    list = internet_address_list_parse_string (from);
+    if (from)
+	list = internet_address_list_parse_string (from);
+
     if (list) {
 	address = internet_address_list_get_address (list, 0);
 	if (address) {
@@ -115,7 +117,7 @@ _thread_add_message (notmuch_thread_t *thread,
     if (! thread->subject) {
 	const char *subject;
 	subject = notmuch_message_get_header (message, "subject");
-	thread->subject = talloc_strdup (thread, subject);
+	thread->subject = talloc_strdup (thread, subject ? subject : "");
     }
 
     for (tags = notmuch_message_get_tags (message);
@@ -127,9 +129,39 @@ _thread_add_message (notmuch_thread_t *thread,
     }
 }
 
+static void
+_thread_set_subject_from_message (notmuch_thread_t *thread,
+				  notmuch_message_t *message)
+{
+    const char *subject;
+    const char *cleaned_subject;
+
+    subject = notmuch_message_get_header (message, "subject");
+    if (! subject)
+	return;
+
+    if ((strncasecmp (subject, "Re: ", 4) == 0) ||
+	(strncasecmp (subject, "Aw: ", 4) == 0) ||
+	(strncasecmp (subject, "Vs: ", 4) == 0) ||
+	(strncasecmp (subject, "Sv: ", 4) == 0)) {
+
+	cleaned_subject = talloc_strndup (thread,
+					  subject + 4,
+					  strlen(subject) - 4);
+    } else {
+	cleaned_subject = talloc_strdup (thread, subject);
+    }
+
+    if (thread->subject)
+	talloc_free (thread->subject);
+
+    thread->subject = talloc_strdup (thread, cleaned_subject);
+}
+
 static void
 _thread_add_matched_message (notmuch_thread_t *thread,
-			     notmuch_message_t *message)
+			     notmuch_message_t *message,
+			     notmuch_sort_t sort)
 {
     time_t date;
     notmuch_message_t *hashed_message;
@@ -150,6 +182,12 @@ _thread_add_matched_message (notmuch_thread_t *thread,
 	notmuch_message_set_flag (hashed_message,
 				  NOTMUCH_MESSAGE_FLAG_MATCH, 1);
     }
+
+    if ((sort == NOTMUCH_SORT_OLDEST_FIRST && date <= thread->newest) ||
+	(sort != NOTMUCH_SORT_OLDEST_FIRST && date == thread->newest))
+    {
+	_thread_set_subject_from_message (thread, message);
+    }
 }
 
 static void
@@ -209,36 +247,56 @@ notmuch_thread_t *
 _notmuch_thread_create (void *ctx,
 			notmuch_database_t *notmuch,
 			const char *thread_id,
-			const char *query_string)
+			const char *query_string,
+			notmuch_sort_t sort)
 {
     notmuch_thread_t *thread;
-    const char *thread_id_query_string, *matched_query_string;
-    notmuch_query_t *thread_id_query, *matched_query;
+    const char *thread_id_query_string;
+    notmuch_query_t *thread_id_query;
+
     notmuch_messages_t *messages;
     notmuch_message_t *message;
+    notmuch_bool_t matched_is_subset_of_thread;
 
     thread_id_query_string = talloc_asprintf (ctx, "thread:%s", thread_id);
     if (unlikely (query_string == NULL))
 	return NULL;
 
-    /* XXX: We could be a bit more efficient here if
-     * thread_id_query_string is identical to query_string, (then we
-     * could get by with just one database search instead of two). */
-
-    matched_query_string = talloc_asprintf (ctx, "%s AND (%s)",
-					    thread_id_query_string,
-					    query_string);
-    if (unlikely (matched_query_string == NULL))
-	return NULL;
+    /* Under normal circumstances we need to do two database
+     * queries. One is for the thread itself (thread_id_query_string)
+     * and the second is to determine which messages in that thread
+     * match the original query (matched_query_string).
+     *
+     * But under two circumstances, we use only the
+     * thread_id_query_string:
+     *
+     *	1. If the original query_string *is* just the thread
+     *	   specification.
+     *
+     *  2. If the original query_string matches all messages ("" or
+     *     "*").
+     *
+     * In either of these cases, we can be more efficient by running
+     * just the thread_id query (since we know all messages in the
+     * thread will match the query_string).
+     *
+     * Beyond the performance advantage, in the second case, it's
+     * important to not try to create a concatenated query because our
+     * parser handles "" and "*" as special cases and will not do the
+     * right thing with a query string of "* and thread:<foo>".
+     **/
+    matched_is_subset_of_thread = 1;
+    if (strcmp (query_string, thread_id_query_string) == 0 ||
+	strcmp (query_string, "") == 0 ||
+	strcmp (query_string, "*") == 0)
+    {
+	matched_is_subset_of_thread = 0;
+    }
 
     thread_id_query = notmuch_query_create (notmuch, thread_id_query_string);
     if (unlikely (thread_id_query == NULL))
 	return NULL;
 
-    matched_query = notmuch_query_create (notmuch, matched_query_string);
-    if (unlikely (thread_id_query == NULL))
-	return NULL;
-
     thread = talloc (ctx, notmuch_thread_t);
     if (unlikely (thread == NULL))
 	return NULL;
@@ -273,22 +331,43 @@ _notmuch_thread_create (void *ctx,
 	 notmuch_messages_move_to_next (messages))
     {
 	message = notmuch_messages_get (messages);
+
 	_thread_add_message (thread, message);
+
+	if (! matched_is_subset_of_thread)
+	    _thread_add_matched_message (thread, message, sort);
+
 	_notmuch_message_close (message);
     }
 
     notmuch_query_destroy (thread_id_query);
 
-    for (messages = notmuch_query_search_messages (matched_query);
-	 notmuch_messages_valid (messages);
-	 notmuch_messages_move_to_next (messages))
+    if (matched_is_subset_of_thread)
     {
-	message = notmuch_messages_get (messages);
-	_thread_add_matched_message (thread, message);
-	_notmuch_message_close (message);
-    }
+	const char *matched_query_string;
+	notmuch_query_t *matched_query;
+
+	matched_query_string = talloc_asprintf (ctx, "%s AND (%s)",
+						thread_id_query_string,
+						query_string);
+	if (unlikely (matched_query_string == NULL))
+	    return NULL;
+
+	matched_query = notmuch_query_create (notmuch, matched_query_string);
+	if (unlikely (matched_query == NULL))
+	    return NULL;
+
+	for (messages = notmuch_query_search_messages (matched_query);
+	     notmuch_messages_valid (messages);
+	     notmuch_messages_move_to_next (messages))
+	{
+	    message = notmuch_messages_get (messages);
+	    _thread_add_matched_message (thread, message, sort);
+	    _notmuch_message_close (message);
+	}
 
-    notmuch_query_destroy (matched_query);
+	notmuch_query_destroy (matched_query);
+    }
 
     _resolve_thread_relationships (thread);