X-Git-Url: https://git.notmuchmail.org/git?p=notmuch;a=blobdiff_plain;f=notmuch-tag.c;h=0a6b140c25a66d4a4e1e898695ffb399ce03c11b;hp=dded39ea5df645799eced2657fa4db1ee20bbe52;hb=8e3ff8fb03dc647f1daea4665c35a2214473ced8;hpb=61f0a5b8ee2adf540106a09c5f83fe634da6beb3 diff --git a/notmuch-tag.c b/notmuch-tag.c index dded39ea..0a6b140c 100644 --- a/notmuch-tag.c +++ b/notmuch-tag.c @@ -26,16 +26,95 @@ static void handle_sigint (unused (int sig)) { static char msg[] = "Stopping... \n"; - 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; @@ -53,35 +132,33 @@ 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; } - argc--; argv++; /* skip subcommand argument */ - for (i = 0; i < argc; i++) { if (strcmp (argv[i], "--") == 0) { 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; } @@ -93,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; @@ -121,12 +206,12 @@ 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);