X-Git-Url: https://git.notmuchmail.org/git?p=notmuch;a=blobdiff_plain;f=notmuch-tag.c;h=0a6b140c25a66d4a4e1e898695ffb399ce03c11b;hp=fd54bc786d84d7f910c5916e8c845dea906b5516;hb=8e3ff8fb03dc647f1daea4665c35a2214473ced8;hpb=8cbb5114a20c1217f23977fd5edca99a0b7a2955 diff --git a/notmuch-tag.c b/notmuch-tag.c index fd54bc78..0a6b140c 100644 --- a/notmuch-tag.c +++ b/notmuch-tag.c @@ -25,19 +25,96 @@ static volatile sig_atomic_t interrupted; static void handle_sigint (unused (int sig)) { - ssize_t ignored; - static char msg[] = "Stopping... \n"; - ignored = write(2, msg, sizeof(msg)-1); + + /* This write is "opportunistic", so it's okay to ignore the + * result. It is not required for correctness, and if it does + * fail or produce a short write, we want to get out of the signal + * handler as quickly as possible, not retry it. */ + IGNORE_RESULT (write (2, msg, sizeof(msg)-1)); interrupted = 1; } +static char * +_escape_tag (char *buf, const char *tag) +{ + const char *in = tag; + char *out = buf; + /* Boolean terms surrounded by double quotes can contain any + * character. Double quotes are quoted by doubling them. */ + *out++ = '"'; + while (*in) { + if (*in == '"') + *out++ = '"'; + *out++ = *in++; + } + *out++ = '"'; + *out = 0; + return buf; +} + +typedef struct { + const char *tag; + notmuch_bool_t remove; +} tag_operation_t; + +static char * +_optimize_tag_query (void *ctx, const char *orig_query_string, + const tag_operation_t *tag_ops) +{ + /* This is subtler than it looks. Xapian ignores the '-' operator + * at the beginning both queries and parenthesized groups and, + * furthermore, the presence of a '-' operator at the beginning of + * a group can inhibit parsing of the previous operator. Hence, + * the user-provided query MUST appear first, but it is safe to + * parenthesize and the exclusion part of the query must not use + * the '-' operator (though the NOT operator is fine). */ + + char *escaped, *query_string; + const char *join = ""; + int i; + unsigned int max_tag_len = 0; + + /* Don't optimize if there are no tag changes. */ + if (tag_ops[0].tag == NULL) + return talloc_strdup (ctx, orig_query_string); + + /* Allocate a buffer for escaping tags. This is large enough to + * hold a fully escaped tag with every character doubled plus + * enclosing quotes and a NUL. */ + for (i = 0; tag_ops[i].tag; i++) + if (strlen (tag_ops[i].tag) > max_tag_len) + max_tag_len = strlen (tag_ops[i].tag); + escaped = talloc_array(ctx, char, max_tag_len * 2 + 3); + if (!escaped) + return NULL; + + /* Build the new query string */ + if (strcmp (orig_query_string, "*") == 0) + query_string = talloc_strdup (ctx, "("); + else + query_string = talloc_asprintf (ctx, "( %s ) and (", orig_query_string); + + for (i = 0; tag_ops[i].tag && query_string; i++) { + query_string = talloc_asprintf_append_buffer ( + query_string, "%s%stag:%s", join, + tag_ops[i].remove ? "" : "not ", + _escape_tag (escaped, tag_ops[i].tag)); + join = " or "; + } + + if (query_string) + query_string = talloc_strdup_append_buffer (query_string, ")"); + + talloc_free (escaped); + return query_string; +} + int -notmuch_tag_command (void *ctx, unused (int argc), unused (char *argv[])) +notmuch_tag_command (void *ctx, int argc, char *argv[]) { - int *add_tags, *remove_tags; - int add_tags_count = 0; - int remove_tags_count = 0; + tag_operation_t *tag_ops; + int tag_ops_count = 0; char *query_string; notmuch_config_t *config; notmuch_database_t *notmuch; @@ -45,6 +122,7 @@ notmuch_tag_command (void *ctx, unused (int argc), unused (char *argv[])) notmuch_messages_t *messages; notmuch_message_t *message; struct sigaction action; + notmuch_bool_t synchronize_flags; int i; /* Setup our handler for SIGINT */ @@ -54,14 +132,12 @@ notmuch_tag_command (void *ctx, unused (int argc), unused (char *argv[])) action.sa_flags = SA_RESTART; sigaction (SIGINT, &action, NULL); - add_tags = talloc_size (ctx, argc * sizeof (int)); - if (add_tags == NULL) { - fprintf (stderr, "Out of memory.\n"); - return 1; - } + argc--; argv++; /* skip subcommand argument */ - remove_tags = talloc_size (ctx, argc * sizeof (int)); - if (remove_tags == NULL) { + /* Array of tagging operations (add or remove), terminated with an + * empty element. */ + tag_ops = talloc_array (ctx, tag_operation_t, argc + 1); + if (tag_ops == NULL) { fprintf (stderr, "Out of memory.\n"); return 1; } @@ -71,16 +147,18 @@ notmuch_tag_command (void *ctx, unused (int argc), unused (char *argv[])) i++; break; } - if (argv[i][0] == '+') { - add_tags[add_tags_count++] = i; - } else if (argv[i][0] == '-') { - remove_tags[remove_tags_count++] = i; + if (argv[i][0] == '+' || argv[i][0] == '-') { + tag_ops[tag_ops_count].tag = argv[i] + 1; + tag_ops[tag_ops_count].remove = (argv[i][0] == '-'); + tag_ops_count++; } else { break; } } - if (add_tags_count == 0 && remove_tags_count == 0) { + tag_ops[tag_ops_count].tag = NULL; + + if (tag_ops_count == 0) { fprintf (stderr, "Error: 'notmuch tag' requires at least one tag to add or remove.\n"); return 1; } @@ -92,6 +170,14 @@ notmuch_tag_command (void *ctx, unused (int argc), unused (char *argv[])) return 1; } + /* Optimize the query so it excludes messages that already have + * the specified set of tags. */ + query_string = _optimize_tag_query (ctx, query_string, tag_ops); + if (query_string == NULL) { + fprintf (stderr, "Out of memory.\n"); + return 1; + } + config = notmuch_config_open (ctx, NULL, NULL); if (config == NULL) return 1; @@ -101,6 +187,8 @@ notmuch_tag_command (void *ctx, unused (int argc), unused (char *argv[])) if (notmuch == NULL) return 1; + synchronize_flags = notmuch_config_get_maildir_synchronize_flags (config); + query = notmuch_query_create (notmuch, query_string); if (query == NULL) { fprintf (stderr, "Out of memory.\n"); @@ -118,15 +206,18 @@ notmuch_tag_command (void *ctx, unused (int argc), unused (char *argv[])) notmuch_message_freeze (message); - for (i = 0; i < remove_tags_count; i++) - notmuch_message_remove_tag (message, - argv[remove_tags[i]] + 1); - - for (i = 0; i < add_tags_count; i++) - notmuch_message_add_tag (message, argv[add_tags[i]] + 1); + for (i = 0; tag_ops[i].tag; i++) { + if (tag_ops[i].remove) + notmuch_message_remove_tag (message, tag_ops[i].tag); + else + notmuch_message_add_tag (message, tag_ops[i].tag); + } notmuch_message_thaw (message); + if (synchronize_flags) + notmuch_message_tags_to_maildir_flags (message); + notmuch_message_destroy (message); }