cli: add support for deduplicating based on case insensitive address

[notmuch] / notmuch-search.c

diff --git a/notmuch-search.c b/notmuch-search.c
index 966c310f8f183b76c0b7c21a341d2841c7fc2917..2eaad32f2abbbeee75eea79fb4f34a1ddb4f83d7 100644 (file)
--- a/notmuch-search.c
+++ b/notmuch-search.c
@@ -39,6 +39,7 @@ typedef enum {
 typedef enum {
     DEDUP_NONE,
     DEDUP_MAILBOX,
+    DEDUP_ADDRESS,
 } dedup_t;
 
 typedef enum {
@@ -265,30 +266,70 @@ static mailbox_t *new_mailbox (void *ctx, const char *name, const char *addr)
     return mailbox;
 }
 
+static int mailbox_compare (const void *v1, const void *v2)
+{
+    const mailbox_t *m1 = v1, *m2 = v2;
+    int ret;
+
+    ret = strcmp_null (m1->name, m2->name);
+    if (! ret)
+       ret = strcmp (m1->addr, m2->addr);
+
+    return ret;
+}
+
 /* Returns TRUE iff name and addr is duplicate. If not, stores the
  * name/addr pair in order to detect subsequent duplicates. */
 static notmuch_bool_t
 is_duplicate (const search_context_t *ctx, const char *name, const char *addr)
 {
     char *key;
+    GList *list, *l;
     mailbox_t *mailbox;
 
-    key = talloc_asprintf (ctx->format, "%s <%s>", name, addr);
-    if (! key)
-       return FALSE;
+    list = g_hash_table_lookup (ctx->addresses, addr);
+    if (list) {
+       mailbox_t find = {
+           .name = name,
+           .addr = addr,
+       };
+
+       l = g_list_find_custom (list, &find, mailbox_compare);
+       if (l) {
+           mailbox = l->data;
+           mailbox->count++;
+           return TRUE;
+       }
+
+       mailbox = new_mailbox (ctx->format, name, addr);
+       if (! mailbox)
+           return FALSE;
 
-    mailbox = g_hash_table_lookup (ctx->addresses, key);
-    if (mailbox) {
-       mailbox->count++;
-       talloc_free (key);
-       return TRUE;
+       /*
+        * XXX: It would be more efficient to prepend to the list, but
+        * then we'd have to store the changed list head back to the
+        * hash table. This check is here just to avoid the compiler
+        * warning for unused result.
+        */
+       if (list != g_list_append (list, mailbox))
+           INTERNAL_ERROR ("appending to list changed list head\n");
+
+       return FALSE;
     }
 
+    key = talloc_strdup (ctx->format, addr);
+    if (! key)
+       return FALSE;
+
     mailbox = new_mailbox (ctx->format, name, addr);
     if (! mailbox)
        return FALSE;
 
-    g_hash_table_insert (ctx->addresses, key, mailbox);
+    list = g_list_append (NULL, mailbox);
+    if (! list)
+       return FALSE;
+
+    g_hash_table_insert (ctx->addresses, key, list);
 
     return FALSE;
 }
@@ -308,7 +349,7 @@ print_mailbox (const search_context_t *ctx, const mailbox_t *mailbox)
     name_addr = internet_address_to_string (ia, FALSE);
 
     if (format->is_text_printer) {
-       if (count > 0) {
+       if (ctx->output & OUTPUT_COUNT) {
            format->integer (format, count);
            format->string (format, "\t");
        }
@@ -322,7 +363,7 @@ print_mailbox (const search_context_t *ctx, const mailbox_t *mailbox)
        format->string (format, addr);
        format->map_key (format, "name-addr");
        format->string (format, name_addr);
-       if (count > 0) {
+       if (ctx->output & OUTPUT_COUNT) {
            format->map_key (format, "count");
            format->integer (format, count);
        }
@@ -359,7 +400,6 @@ process_address_list (const search_context_t *ctx,
            mailbox_t mbx = {
                .name = internet_address_get_name (address),
                .addr = internet_address_mailbox_get_addr (mailbox),
-               .count = 0,
            };
 
            /* OUTPUT_COUNT only works with deduplication */
@@ -367,7 +407,8 @@ process_address_list (const search_context_t *ctx,
                is_duplicate (ctx, mbx.name, mbx.addr))
                continue;
 
-           if (ctx->output & OUTPUT_COUNT)
+           /* OUTPUT_COUNT and DEDUP_ADDRESS require a full pass. */
+           if (ctx->output & OUTPUT_COUNT || ctx->dedup == DEDUP_ADDRESS)
                continue;
 
            print_mailbox (ctx, &mbx);
@@ -401,14 +442,56 @@ _talloc_free_for_g_hash (void *ptr)
 }
 
 static void
-print_hash_value (unused (gpointer key), gpointer value, gpointer user_data)
+_list_free_for_g_hash (void *ptr)
+{
+    g_list_free_full (ptr, _talloc_free_for_g_hash);
+}
+
+/* Print the most common variant of a list of unique mailboxes, and
+ * conflate the counts. */
+static void
+print_popular (const search_context_t *ctx, GList *list)
 {
-    const mailbox_t *mailbox = value;
-    search_context_t *ctx = user_data;
+    GList *l;
+    mailbox_t *mailbox = NULL, *m;
+    int max = 0;
+    int total = 0;
+
+    for (l = list; l; l = l->next) {
+       m = l->data;
+       total += m->count;
+       if (m->count > max) {
+           mailbox = m;
+           max = m->count;
+       }
+    }
+
+    if (! mailbox)
+       INTERNAL_ERROR("Empty list in address hash table\n");
+
+    /* The original count is no longer needed, so overwrite. */
+    mailbox->count = total;
 
     print_mailbox (ctx, mailbox);
 }
 
+static void
+print_list_value (void *mailbox, void *context)
+{
+    print_mailbox (context, mailbox);
+}
+
+static void
+print_hash_value (unused (void *key), void *list, void *context)
+{
+    const search_context_t *ctx = context;
+
+    if (ctx->dedup == DEDUP_ADDRESS)
+       print_popular (ctx, list);
+    else
+       g_list_foreach (list, print_list_value, context);
+}
+
 static int
 _count_filenames (notmuch_message_t *message)
 {
@@ -505,7 +588,8 @@ do_search_messages (search_context_t *ctx)
        notmuch_message_destroy (message);
     }
 
-    if (ctx->addresses && ctx->output & OUTPUT_COUNT)
+    if (ctx->addresses &&
+       (ctx->output & OUTPUT_COUNT || ctx->dedup == DEDUP_ADDRESS))
        g_hash_table_foreach (ctx->addresses, print_hash_value, ctx);
 
     notmuch_messages_destroy (messages);
@@ -770,6 +854,7 @@ notmuch_address_command (notmuch_config_t *config, int argc, char *argv[])
        { NOTMUCH_OPT_KEYWORD, &ctx->dedup, "deduplicate", 'D',
          (notmuch_keyword_t []){ { "no", DEDUP_NONE },
                                  { "mailbox", DEDUP_MAILBOX },
+                                 { "address", DEDUP_ADDRESS },
                                  { 0, 0 } } },
        { NOTMUCH_OPT_INHERIT, (void *) &common_options, NULL, 0, 0 },
        { NOTMUCH_OPT_INHERIT, (void *) &notmuch_shared_options, NULL, 0, 0 },
@@ -794,8 +879,9 @@ notmuch_address_command (notmuch_config_t *config, int argc, char *argv[])
                                 argc - opt_index, argv + opt_index))
        return EXIT_FAILURE;
 
-    ctx->addresses = g_hash_table_new_full (g_str_hash, g_str_equal,
-                                           _talloc_free_for_g_hash, _talloc_free_for_g_hash);
+    ctx->addresses = g_hash_table_new_full (strcase_hash, strcase_equal,
+                                           _talloc_free_for_g_hash,
+                                           _list_free_for_g_hash);
 
     ret = do_search_messages (ctx);