query.c

Go to the documentation of this file.

 
#include "config.h"
#include <stddef.h>
#include <stdio.h>
#include "mutt/lib.h"
#include "config/lib.h"
#include "query.h"

static const struct Mapping NmQueryTypeMethods[] = {
  // clang-format off
  { "messages", NM_QUERY_TYPE_MESSAGES },
  { "threads",  NM_QUERY_TYPE_THREADS  },
  { NULL, 0 },
  // clang-format on
};

const struct EnumDef NmQueryTypeDef = {
  "nm_query_type",
  2,
  (struct Mapping *) &NmQueryTypeMethods,
};

static const struct Mapping NmTimebaseMethods[] = {
  // clang-format off
  { "hour",  NMTB_HOUR  },
  { "day",   NMTB_DAY   },
  { "week",  NMTB_WEEK  },
  { "month", NMTB_MONTH },
  { "year",  NMTB_YEAR  },
  { NULL, 0 },
  // clang-format on
};

const struct EnumDef NmQueryWindowTimebaseDef = {
  "nm_query_window_timebase",
  5,
  (struct Mapping *) &NmTimebaseMethods,
};

enum NmQueryType nm_parse_type_from_query(char *buf, enum NmQueryType fallback)
{
  enum NmQueryType query_type = fallback;
 
  if (!buf)
    return query_type;
 
  size_t buflen = mutt_str_len(buf);
  const char *message_ptr = mutt_istrn_rfind(buf, buflen, "type=messages");
  const char *thread_ptr = mutt_istrn_rfind(buf, buflen, "type=threads");
 
  // No valid type statement found.
  if (!message_ptr && !thread_ptr)
    return query_type;
 
  // Determine the last valid "type=" statement.
  if ((!message_ptr && thread_ptr) || (thread_ptr > message_ptr))
  {
    query_type = NM_QUERY_TYPE_THREADS;
  }
  else
  {
    query_type = NM_QUERY_TYPE_MESSAGES;
  }
 
  // Clean-up any valid "type=" statements.
  // The six variations of how "type=" could appear.
  const char *variants[6] = { "&type=threads", "&type=messages",
                              "type=threads&", "type=messages&",
                              "type=threads",  "type=messages" };
  int variants_size = countof(variants);
 
  for (int i = 0; i < variants_size; i++)
  {
    mutt_istr_remall(buf, variants[i]);
  }
 
  return query_type;
}

const char *nm_query_type_to_string(enum NmQueryType query_type)
{
  const char *name = mutt_map_get_name(query_type, NmQueryTypeMethods);
  return name ? name : "messages";
}

enum NmQueryType nm_string_to_query_type(const char *str)
{
  enum NmQueryType query_type = nm_string_to_query_type_mapper(str);
 
  if (query_type == NM_QUERY_TYPE_UNKNOWN)
  {
    mutt_error(_("failed to parse notmuch query type: %s"), NONULL(str));
    return NM_QUERY_TYPE_MESSAGES;
  }
 
  return query_type;
}

enum NmQueryType nm_string_to_query_type_mapper(const char *str)
{
  int query_type = mutt_map_get_value(str, NmQueryTypeMethods);
  return (query_type < 0) ? NM_QUERY_TYPE_UNKNOWN : query_type;
}

enum NmWindowQueryRc
nm_windowed_query_from_query(char *buf, size_t buflen, const bool force_enable,
                             const short duration, const short cur_pos, const char *cur_search,
                             const enum NmTimebase timebase, const char *or_terms)
{
  // if the duration is a non positive integer, disable the window unless the
  // user explicitly enables windowed queries.
  if (!force_enable && (duration <= 0))
  {
    return NM_WINDOW_QUERY_INVALID_DURATION;
  }
 
  int beg = duration * (cur_pos + 1);
  int end = duration * cur_pos;
 
  // If the duration is 0, we want to generate a query spanning a single timebase.
  // For example, `date:1month..1month` spans the previous month.
  if ((duration == 0) && (cur_pos != 0))
  {
    end = cur_pos;
    beg = end;
  }
 
  const char *timebase_str = mutt_map_get_name(timebase, NmTimebaseMethods);
  if (!timebase_str)
  {
    return NM_WINDOW_QUERY_INVALID_TIMEBASE;
  }
 
  size_t length = 0;
  if (end == 0)
  {
    // Open-ended date allows mail from the future.
    // This may occur is the sender's time settings are off.
    length = snprintf(buf, buflen, "date:%d%s..", beg, timebase_str);
  }
  else
  {
    length = snprintf(buf, buflen, "date:%d%s..%d%s", beg, timebase_str, end, timebase_str);
  }
 
  if (!mutt_str_equal(or_terms, ""))
  {
    char *date_part = mutt_str_dup(buf);
    length = snprintf(buf, buflen, "(%s or (%s))", date_part, or_terms);
    FREE(&date_part);
  }
 
  // Add current search to window query.
  snprintf(buf + length, buflen - length, " and %s", cur_search);
 
  return NM_WINDOW_QUERY_SUCCESS;
}