From 2ca5a760ada9f57c62445070f51525834163732e Mon Sep 17 00:00:00 2001 From: david Date: Mon, 19 Nov 2012 15:04:51 +2000 Subject: [PATCH] [PATCH 09/16] cli: add support for batch tagging operations to "notmuch tag" --- 45/0b4bfbfde44ef1adf26bcb83f92e124a3b692b | 342 ++++++++++++++++++++++ 1 file changed, 342 insertions(+) create mode 100644 45/0b4bfbfde44ef1adf26bcb83f92e124a3b692b diff --git a/45/0b4bfbfde44ef1adf26bcb83f92e124a3b692b b/45/0b4bfbfde44ef1adf26bcb83f92e124a3b692b new file mode 100644 index 000000000..5d8b7d605 --- /dev/null +++ b/45/0b4bfbfde44ef1adf26bcb83f92e124a3b692b @@ -0,0 +1,342 @@ +Return-Path: +X-Original-To: notmuch@notmuchmail.org +Delivered-To: notmuch@notmuchmail.org +Received: from localhost (localhost [127.0.0.1]) + by olra.theworths.org (Postfix) with ESMTP id E40F1431FBF + for ; Sun, 18 Nov 2012 11:05:38 -0800 (PST) +X-Virus-Scanned: Debian amavisd-new at olra.theworths.org +X-Spam-Flag: NO +X-Spam-Score: 0 +X-Spam-Level: +X-Spam-Status: No, score=0 tagged_above=-999 required=5 tests=[none] + autolearn=disabled +Received: from olra.theworths.org ([127.0.0.1]) + by localhost (olra.theworths.org [127.0.0.1]) (amavisd-new, port 10024) + with ESMTP id Sfnp1vpZ3h44 for ; + Sun, 18 Nov 2012 11:05:36 -0800 (PST) +Received: from tesseract.cs.unb.ca (tesseract.cs.unb.ca [131.202.240.238]) + (using TLSv1 with cipher AES256-SHA (256/256 bits)) + (No client certificate requested) + by olra.theworths.org (Postfix) with ESMTPS id EB9CB429E26 + for ; Sun, 18 Nov 2012 11:05:19 -0800 (PST) +Received: from fctnnbsc30w-156034089108.dhcp-dynamic.fibreop.nb.bellaliant.net + ([156.34.89.108] helo=zancas.localnet) + by tesseract.cs.unb.ca with esmtpsa + (TLS1.0:DHE_RSA_AES_128_CBC_SHA1:16) (Exim 4.72) + (envelope-from ) + id 1TaABC-000289-8T; Sun, 18 Nov 2012 15:05:18 -0400 +Received: from bremner by zancas.localnet with local (Exim 4.80) + (envelope-from ) + id 1TaAB6-0001Io-O1; Sun, 18 Nov 2012 15:05:12 -0400 +From: david@tethera.net +To: notmuch@notmuchmail.org +Subject: [PATCH 09/16] cli: add support for batch tagging operations to + "notmuch tag" +Date: Sun, 18 Nov 2012 15:04:51 -0400 +Message-Id: <1353265498-3839-10-git-send-email-david@tethera.net> +X-Mailer: git-send-email 1.7.10.4 +In-Reply-To: <1353265498-3839-1-git-send-email-david@tethera.net> +References: <1353265498-3839-1-git-send-email-david@tethera.net> +X-Spam_bar: - +X-BeenThere: notmuch@notmuchmail.org +X-Mailman-Version: 2.1.13 +Precedence: list +List-Id: "Use and development of the notmuch mail system." + +List-Unsubscribe: , + +List-Archive: +List-Post: +List-Help: +List-Subscribe: , + +X-List-Received-Date: Sun, 18 Nov 2012 19:05:39 -0000 + +From: Jani Nikula + +Add support for batch tagging operations through stdin to "notmuch +tag". This can be enabled with the new --stdin command line option to +"notmuch new". The input must consist of lines of the format: + ++|- [...] [--] + +Each line is interpreted similarly to "notmuch tag" command line +arguments. The delimiter is one or more spaces ' '. Any characters in + and MAY be hex encoded with %NN where NN is the +hexadecimal value of the character. Any ' ' and '%' characters in + and MUST be hex encoded (using %20 and %25, +respectively). Any characters that are not part of or + MUST NOT be hex encoded. + +Leading and trailing space ' ' is ignored. Empty lines and lines +beginning with '#' are ignored. + +Signed-off-by: Jani Nikula + +Hacked-like-crazy-by: David Bremner +--- + notmuch-tag.c | 177 +++++++++++++++++++++++++++++++++++---------------------- + 1 file changed, 109 insertions(+), 68 deletions(-) + +diff --git a/notmuch-tag.c b/notmuch-tag.c +index 88d559b..ca120d5 100644 +--- a/notmuch-tag.c ++++ b/notmuch-tag.c +@@ -19,6 +19,7 @@ + */ + + #include "notmuch-client.h" ++#include "tag-util.h" + + static volatile sig_atomic_t interrupted; + +@@ -54,14 +55,9 @@ _escape_tag (char *buf, const char *tag) + 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) ++ const tag_op_list_t *list) + { + /* This is subtler than it looks. Xapian ignores the '-' operator + * at the beginning both queries and parenthesized groups and, +@@ -75,6 +71,7 @@ _optimize_tag_query (void *ctx, const char *orig_query_string, + const char *join = ""; + int i; + unsigned int max_tag_len = 0; ++ const tag_operation_t *tag_ops = list->ops; + + /* Don't optimize if there are no tag changes. */ + if (tag_ops[0].tag == NULL) +@@ -116,12 +113,11 @@ _optimize_tag_query (void *ctx, const char *orig_query_string, + * element. */ + static int + tag_query (void *ctx, notmuch_database_t *notmuch, const char *query_string, +- tag_operation_t *tag_ops, notmuch_bool_t synchronize_flags) ++ tag_op_list_t *tag_ops, tag_op_flag_t flags) + { + notmuch_query_t *query; + notmuch_messages_t *messages; + notmuch_message_t *message; +- int i; + + /* Optimize the query so it excludes messages that already have + * the specified set of tags. */ +@@ -144,21 +140,7 @@ tag_query (void *ctx, notmuch_database_t *notmuch, const char *query_string, + notmuch_messages_valid (messages) && ! interrupted; + notmuch_messages_move_to_next (messages)) { + message = notmuch_messages_get (messages); +- +- notmuch_message_freeze (message); +- +- 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); +- ++ tag_op_list_apply (message, tag_ops, flags); + notmuch_message_destroy (message); + } + +@@ -170,15 +152,17 @@ tag_query (void *ctx, notmuch_database_t *notmuch, const char *query_string, + int + notmuch_tag_command (void *ctx, int argc, char *argv[]) + { +- tag_operation_t *tag_ops; +- int tag_ops_count = 0; +- char *query_string; ++ tag_op_list_t *tag_ops = NULL; ++ char *query_string = NULL; + notmuch_config_t *config; + notmuch_database_t *notmuch; + struct sigaction action; +- notmuch_bool_t synchronize_flags; +- int i; +- int ret; ++ tag_op_flag_t synchronize_flags = TAG_FLAG_NONE; ++ notmuch_bool_t batch = FALSE; ++ FILE *input = stdin; ++ char *input_file_name = NULL; ++ int i, opt_index; ++ int ret = 0; + + /* Setup our handler for SIGINT */ + memset (&action, 0, sizeof (struct sigaction)); +@@ -187,53 +171,76 @@ notmuch_tag_command (void *ctx, int argc, char *argv[]) + action.sa_flags = SA_RESTART; + sigaction (SIGINT, &action, NULL); + +- argc--; argv++; /* skip subcommand argument */ ++ notmuch_opt_desc_t options[] = { ++ { NOTMUCH_OPT_BOOLEAN, &batch, "batch", 0, 0 }, ++ { NOTMUCH_OPT_STRING, &input_file_name, "input", 'i', 0 }, ++ { 0, 0, 0, 0, 0 } ++ }; + +- /* 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"); ++ opt_index = parse_arguments (argc, argv, options, 1); ++ if (opt_index < 0) + return 1; ++ ++ if (input_file_name) { ++ batch = TRUE; ++ input = fopen (input_file_name, "r"); ++ if (input == NULL) { ++ fprintf (stderr, "Error opening %s for reading: %s\n", ++ input_file_name, strerror (errno)); ++ return 1; ++ } + } + +- for (i = 0; i < argc; i++) { +- if (strcmp (argv[i], "--") == 0) { +- i++; +- break; ++ if (batch) { ++ if (opt_index != argc) { ++ fprintf (stderr, "Can't specify both cmdline and stdin!\n"); ++ return 1; + } +- if (argv[i][0] == '+' || argv[i][0] == '-') { +- if (argv[i][0] == '+' && argv[i][1] == '\0') { +- fprintf (stderr, "Error: tag names cannot be empty.\n"); +- return 1; ++ } else { ++ /* Array of tagging operations (add or remove), terminated with an ++ * empty element. */ ++ tag_ops = tag_op_list_create (ctx); ++ if (tag_ops == NULL) { ++ fprintf (stderr, "Out of memory.\n"); ++ return 1; ++ } ++ ++ for (i = opt_index; i < argc; i++) { ++ if (strcmp (argv[i], "--") == 0) { ++ i++; ++ break; + } +- if (argv[i][0] == '+' && argv[i][1] == '-') { +- /* This disallows adding the non-removable tag "-" and +- * enables notmuch tag to take long options in the +- * future. */ +- fprintf (stderr, "Error: tag names must not start with '-'.\n"); +- return 1; ++ if (argv[i][0] == '+' || argv[i][0] == '-') { ++ /* FIXME: checks should be consistent with those in batch tagging */ ++ if (argv[i][0] == '+' && argv[i][1] == '\0') { ++ fprintf (stderr, "Error: tag names cannot be empty.\n"); ++ return 1; ++ } ++ if (argv[i][0] == '+' && argv[i][1] == '-') { ++ /* This disallows adding the non-removable tag "-" and ++ * enables notmuch tag to take long options in the ++ * future. */ ++ fprintf (stderr, "Error: tag names must not start with '-'.\n"); ++ return 1; ++ } ++ tag_op_list_append (ctx, tag_ops, ++ argv[i] + 1, (argv[i][0] == '-')); ++ } else { ++ break; + } +- tag_ops[tag_ops_count].tag = argv[i] + 1; +- tag_ops[tag_ops_count].remove = (argv[i][0] == '-'); +- tag_ops_count++; +- } else { +- break; + } +- } +- +- 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; +- } ++ if (tag_op_list_empty (tag_ops)) { ++ fprintf (stderr, "Error: 'notmuch tag' requires at least one tag to add or remove.\n"); ++ return 1; ++ } + +- query_string = query_string_from_args (ctx, argc - i, &argv[i]); ++ query_string = query_string_from_args (ctx, argc - i, &argv[i]); + +- if (*query_string == '\0') { +- fprintf (stderr, "Error: notmuch tag requires at least one search term.\n"); +- return 1; ++ if (*query_string == '\0') { ++ fprintf (stderr, "Error: notmuch tag requires at least one search term.\n"); ++ return 1; ++ } + } + + config = notmuch_config_open (ctx, NULL, NULL); +@@ -244,11 +251,45 @@ notmuch_tag_command (void *ctx, int argc, char *argv[]) + NOTMUCH_DATABASE_MODE_READ_WRITE, ¬much)) + return 1; + +- synchronize_flags = notmuch_config_get_maildir_synchronize_flags (config); ++ if (notmuch_config_get_maildir_synchronize_flags (config)) ++ synchronize_flags = TAG_FLAG_MAILDIR_SYNC; ++ ++ if (batch) { ++ ++ char *line = NULL; ++ size_t line_size = 0; ++ ssize_t line_len; ++ int ret = 0; ++ tag_op_list_t *tag_ops; ++ ++ tag_ops = tag_op_list_create (ctx); ++ if (tag_ops == NULL) { ++ fprintf (stderr, "Out of memory.\n"); ++ return 1; ++ } ++ ++ while ((line_len = getline (&line, &line_size, input)) != -1 && ++ ! interrupted) { ++ ++ char *query_string; ++ ++ ret = parse_tag_line (ctx, line, &query_string, tag_ops); + +- ret = tag_query (ctx, notmuch, query_string, tag_ops, synchronize_flags); ++ if (ret > 0) ++ continue; ++ ++ if (ret < 0 || tag_query (ctx, notmuch, query_string, ++ tag_ops, synchronize_flags)) ++ break; ++ } ++ ++ if (line) ++ free (line); ++ } else ++ ret = tag_query (ctx, notmuch, query_string, tag_ops, synchronize_flags); + + notmuch_database_destroy (notmuch); + +- return ret; ++ return ret || interrupted; ++ + } +-- +1.7.10.4 + -- 2.26.2