complete ghost-on-removal-when-shared-thread-exists

[notmuch] / lib / message.cc

diff --git a/lib/message.cc b/lib/message.cc
index 415eac1b9862033f7cf05f9f49d08eaf440b70de..68393055b3eb73b73ee3a1a4b5bde38ce8d94c73 100644 (file)
--- a/lib/message.cc
+++ b/lib/message.cc
@@ -1044,10 +1044,13 @@ _notmuch_message_delete (notmuch_message_t *message)
 {
     notmuch_status_t status;
     Xapian::WritableDatabase *db;
-    const char *mid, *tid;
+    const char *mid, *tid, *query_string;
     notmuch_message_t *ghost;
     notmuch_private_status_t private_status;
     notmuch_database_t *notmuch;
+    notmuch_query_t *query;
+    unsigned int count = 0;
+    notmuch_bool_t is_ghost;
 
     mid = notmuch_message_get_message_id (message);
     tid = notmuch_message_get_thread_id (message);
@@ -1060,21 +1063,64 @@ _notmuch_message_delete (notmuch_message_t *message)
     db = static_cast <Xapian::WritableDatabase *> (notmuch->xapian_db);
     db->delete_document (message->doc_id);
 
-    /* and reintroduce a ghost in its place */
-    ghost = _notmuch_message_create_for_message_id (notmuch, mid, &private_status);
-    if (private_status == NOTMUCH_PRIVATE_STATUS_NO_DOCUMENT_FOUND) {
-       private_status = _notmuch_message_initialize_ghost (ghost, tid);
-       if (! private_status)
-           _notmuch_message_sync (ghost);
-    } else if (private_status == NOTMUCH_PRIVATE_STATUS_SUCCESS) {
-       /* this is deeply weird, and we should not have gotten into
-          this state.  is there a better error message to return
-          here? */
-       return NOTMUCH_STATUS_DUPLICATE_MESSAGE_ID;
+    /* if this was a ghost to begin with, we are done */
+    private_status = _notmuch_message_has_term (message, "type", "ghost", &is_ghost);
+    if (private_status)
+       return COERCE_STATUS (private_status,
+                             "Error trying to determine whether message was a ghost");
+    if (is_ghost)
+       return NOTMUCH_STATUS_SUCCESS;
+
+    query_string = talloc_asprintf (message, "thread:%s", tid);
+    query = notmuch_query_create (notmuch, query_string);
+    if (query == NULL)
+       return NOTMUCH_STATUS_OUT_OF_MEMORY;
+    status = notmuch_query_count_messages_st (query, &count);
+    if (status) {
+       notmuch_query_destroy (query);
+       return status;
     }
 
-    notmuch_message_destroy (ghost);
-    return COERCE_STATUS (private_status, "Error converting to ghost message");
+    if (count > 0) {
+       /* reintroduce a ghost in its place because there are still
+        * other active messages in this thread: */
+       ghost = _notmuch_message_create_for_message_id (notmuch, mid, &private_status);
+       if (private_status == NOTMUCH_PRIVATE_STATUS_NO_DOCUMENT_FOUND) {
+           private_status = _notmuch_message_initialize_ghost (ghost, tid);
+           if (! private_status)
+               _notmuch_message_sync (ghost);
+       } else if (private_status == NOTMUCH_PRIVATE_STATUS_SUCCESS) {
+           /* this is deeply weird, and we should not have gotten
+              into this state.  is there a better error message to
+              return here? */
+           status = NOTMUCH_STATUS_DUPLICATE_MESSAGE_ID;
+       }
+
+       notmuch_message_destroy (ghost);
+       status = COERCE_STATUS (private_status, "Error converting to ghost message");
+    } else {
+       /* the thread is empty; drop all ghost messages from it */
+       notmuch_messages_t *messages;
+       status = _notmuch_query_search_documents (query,
+                                                 "ghost",
+                                                 &messages);
+       if (status == NOTMUCH_STATUS_SUCCESS) {
+           notmuch_status_t last_error = NOTMUCH_STATUS_SUCCESS;
+           while (notmuch_messages_valid (messages)) {
+               message = notmuch_messages_get (messages);
+               status = _notmuch_message_delete (message);
+               if (status) /* we'll report the last failure we see;
+                            * if there is more than one failure, we
+                            * forget about previous ones */
+                   last_error = status;
+               notmuch_message_destroy (message);
+               notmuch_messages_move_to_next (messages);
+           }
+           status = last_error;
+       }
+    }
+    notmuch_query_destroy (query);
+    return status;
 }
 
 /* Transform a blank message into a ghost message.  The caller must
@@ -1217,6 +1263,41 @@ _notmuch_message_remove_term (notmuch_message_t *message,
     return NOTMUCH_PRIVATE_STATUS_SUCCESS;
 }
 
+notmuch_private_status_t
+_notmuch_message_has_term (notmuch_message_t *message,
+                          const char *prefix_name,
+                          const char *value,
+                          notmuch_bool_t *result)
+{
+    char *term;
+    notmuch_bool_t out = FALSE;
+    notmuch_private_status_t status = NOTMUCH_PRIVATE_STATUS_SUCCESS;
+
+    if (value == NULL)
+       return NOTMUCH_PRIVATE_STATUS_NULL_POINTER;
+
+    term = talloc_asprintf (message, "%s%s",
+                           _find_prefix (prefix_name), value);
+
+    if (strlen (term) > NOTMUCH_TERM_MAX)
+       return NOTMUCH_PRIVATE_STATUS_TERM_TOO_LONG;
+
+    try {
+       /* Look for the exact term */
+       Xapian::TermIterator i = message->doc.termlist_begin ();
+       i.skip_to (term);
+       if (i != message->doc.termlist_end () &&
+           !strcmp ((*i).c_str (), term))
+           out = TRUE;
+    } catch (Xapian::Error &error) {
+       status = NOTMUCH_PRIVATE_STATUS_XAPIAN_EXCEPTION;
+    }
+    talloc_free (term);
+
+    *result = out;
+    return status;
+}
+
 notmuch_status_t
 notmuch_message_add_tag (notmuch_message_t *message, const char *tag)
 {