emacs
/
mu
mirror of https://github.com/djcb/mu.git
1
0
Fork 0
Code Issues Releases Wiki Activity

update code for Mu::MessagePriority 

Update dependent code
This commit is contained in:
Dirk-Jan C. Binnema 2022-02-13 14:32:10 +02:00
parent 13bcc6eb5d
commit 23fc8bdba8
10 changed files with 84 additions and 102 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
guile/mu-guile-message.cc
View File

@ -134,9 +134,9 @@ static SCM
get_prio_scm(MuMsg* msg)
{
switch (mu_msg_get_prio(msg)) {
case MU_MSG_PRIO_LOW: return SYMB_PRIO_LOW;
case MU_MSG_PRIO_NORMAL: return SYMB_PRIO_NORMAL;
case MU_MSG_PRIO_HIGH: return SYMB_PRIO_HIGH;
case MessagePriority::Low: return SYMB_PRIO_LOW;
case MessagePriority::Normal: return SYMB_PRIO_NORMAL;
case MessagePriority::High: return SYMB_PRIO_HIGH;
default: g_return_val_if_reached(SCM_UNDEFINED);
}

7
lib/meson.build
View File

@ -61,12 +61,13 @@ lib_mu=static_library(
'mu-msg-file.hh',
'mu-msg-part.cc',
'mu-msg-part.hh',
'mu-msg-prio.c',
'mu-msg-prio.h',
'mu-msg-priv.hh',
'mu-msg-sexp.cc',
'mu-msg.cc',
'mu-msg.hh'
'mu-msg.hh',
'mu-message-priority.hh'
'mu-message-priority.hh',
'mu-message-priority.cc'
],
dependencies: [
glib_dep,

38
lib/mu-msg-file.cc
View File

@ -438,41 +438,41 @@ get_size(MuMsgFile* self)
return self->_size;
}
static MuMsgPrio
static MessagePriority
parse_prio_str(const char* priostr)
{
int i;
struct {
const char* _str;
MuMsgPrio _prio;
} str_prio[] = {{"high", MU_MSG_PRIO_HIGH},
{"1", MU_MSG_PRIO_HIGH},
{"2", MU_MSG_PRIO_HIGH},
const char* _str;
MessagePriority _prio;
} str_prio[] = {{"high", MessagePriority::High},
{"1", MessagePriority::High},
{"2", MessagePriority::High},
{"normal", MU_MSG_PRIO_NORMAL},
{"3", MU_MSG_PRIO_NORMAL},
{"normal", MessagePriority::Normal},
{"3", MessagePriority::Normal},
{"low", MU_MSG_PRIO_LOW},
{"list", MU_MSG_PRIO_LOW},
{"bulk", MU_MSG_PRIO_LOW},
{"4", MU_MSG_PRIO_LOW},
{"5", MU_MSG_PRIO_LOW}};
{"low", MessagePriority::Low},
{"list", MessagePriority::Low},
{"bulk", MessagePriority::Low},
{"4", MessagePriority::Low},
{"5", MessagePriority::Low}};
for (i = 0; i != G_N_ELEMENTS(str_prio); ++i)
if (g_ascii_strcasecmp(priostr, str_prio[i]._str) == 0)
return str_prio[i]._prio;
/* e.g., last-fm uses 'fm-user'... as precedence */
return MU_MSG_PRIO_NORMAL;
return MessagePriority::Normal;
}
static MuMsgPrio
static MessagePriority
get_prio(MuMsgFile* self)
{
GMimeObject* obj;
const char* priostr;
g_return_val_if_fail(self, MU_MSG_PRIO_NONE);
g_return_val_if_fail(self, MessagePriority::Normal);
obj = GMIME_OBJECT(self->_mime_msg);
@ -481,8 +481,10 @@ get_prio(MuMsgFile* self)
priostr = g_mime_object_get_header(obj, "X-Priority");
if (!priostr)
priostr = g_mime_object_get_header(obj, "Importance");
return priostr ? parse_prio_str(priostr) : MU_MSG_PRIO_NORMAL;
if (!priostr)
return MessagePriority::Normal;
else
return parse_prio_str(priostr);
}
/* NOTE: buffer will be *freed* or returned unchanged */

7
lib/mu-msg-sexp.cc
View File

@ -261,10 +261,10 @@ make_part_types(MuMsgPartType ptype)
static void
each_part(MuMsg* msg, MuMsgPart* part, PartInfo* pinfo)
{
auto mimetype = format("%s/%s",
auto mimetype = format("%s/%s",
part->type ? part->type : "application",
part->subtype ? part->subtype : "octet-stream");
auto maybe_attach = Sexp::make_symbol(mu_msg_part_maybe_attachment(part) ? "t" : "nil");
auto maybe_attach = Sexp::make_symbol(mu_msg_part_maybe_attachment(part) ? "t" : "nil");
Sexp::List partlist;
partlist.add_prop(":index", Sexp::make_number(part->index));
@ -385,7 +385,8 @@ Mu::msg_to_sexp_list(MuMsg* msg, unsigned docid, MuMsgOptions opts)
add_prop_nonempty(items, ":path", mu_msg_get_path(msg));
add_prop_nonempty(items, ":maildir", mu_msg_get_maildir(msg));
items.add_prop(":priority", Sexp::make_symbol(mu_msg_prio_name(mu_msg_get_prio(msg))));
items.add_prop(":priority",
Sexp::make_symbol_sv(message_priority_name(mu_msg_get_prio(msg))));
/* in the no-headers-only case (see below) we get a more complete list of contacts, so no
* need to get them here if that's the case */

8
lib/mu-msg.cc
View File

@ -427,11 +427,13 @@ Mu::mu_msg_get_size(MuMsg* self)
return (size_t)get_num_field(self, MU_MSG_FIELD_ID_SIZE);
}
MuMsgPrio
Mu::MessagePriority
Mu::mu_msg_get_prio(MuMsg* self)
{
g_return_val_if_fail(self, MU_MSG_PRIO_NORMAL);
return (MuMsgPrio)get_num_field(self, MU_MSG_FIELD_ID_PRIO);
g_return_val_if_fail(self, MessagePriority{});
return message_priority_from_char(
static_cast<char>(get_num_field(self, MU_MSG_FIELD_ID_PRIO)));
}
struct _BodyData {

16
lib/mu-msg.hh
View File

@ -1,5 +1,5 @@
/*
** Copyright (C) 2010-2020 Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
** Copyright (C) 2010-2022 Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
**
** This program is free software; you can redistribute it and/or modify
** it under the terms of the GNU General Public License as published by
@ -22,7 +22,7 @@
#include <mu-flags.hh>
#include <mu-msg-fields.h>
#include <mu-msg-prio.h>
#include <mu-message-priority.hh>
#include <utils/mu-util.h>
#include <utils/mu-utils.hh>
#include <utils/mu-option.hh>
@ -339,17 +339,15 @@ const GSList* mu_msg_get_field_string_list(MuMsg* self, MuMsgFieldId mfid);
gint64 mu_msg_get_field_numeric(MuMsg* msg, MuMsgFieldId mfid);
/**
* get the message priority for this message (MU_MSG_PRIO_LOW,
* MU_MSG_PRIO_NORMAL or MU_MSG_PRIO_HIGH) the X-Priority,
* X-MSMailPriority, Importance and Precedence header are checked, in
* that order. if no known or explicit priority is set,
* MU_MSG_PRIO_NORMAL is assumed
* get the message priority for this message. The X-Priority, X-MSMailPriority,
* Importance and Precedence header are checked, in that order. if no known or
* explicit priority is set, MessagePriority::Id::Normal is assumed
*
* @param msg a valid MuMsg* instance
*
* @return the message priority (!= 0) or 0 in case of error
* @return the message priority
*/
MuMsgPrio mu_msg_get_prio(MuMsg* msg);
MessagePriority mu_msg_get_prio(MuMsg* msg);
/**
* get the timestamp (mtime) for the file containing this message

47
lib/mu-store.cc
View File

@ -87,20 +87,6 @@ add_synonym_for_flag(MuFlags flag, Xapian::WritableDatabase* db)
pfx + (std::string(1, (char)(tolower(mu_flag_char(flag))))));
}
static void
add_synonym_for_prio(MuMsgPrio prio, Xapian::WritableDatabase* db)
{
static const std::string pfx(prefix(MU_MSG_FIELD_ID_PRIO));
std::string s1(pfx + mu_msg_prio_name(prio));
std::string s2(pfx + (std::string(1, mu_msg_prio_char(prio))));
db->clear_synonyms(s1);
db->clear_synonyms(s2);
db->add_synonym(s1, s2);
}
struct Store::Private {
enum struct XapianOpts { ReadOnly,
Open,
@ -222,8 +208,17 @@ struct Store::Private {
void add_synonyms()
{
mu_flags_foreach((MuFlagsForeachFunc)add_synonym_for_flag, &writable_db());
mu_msg_prio_foreach((MuMsgPrioForeachFunc)add_synonym_for_prio, &writable_db());
mu_flags_foreach((MuFlagsForeachFunc)add_synonym_for_flag,
&writable_db());
for (auto&& prio : AllMessagePriorities) {
const auto s1{prefix(MU_MSG_FIELD_ID_PRIO) + to_string(prio)};
const auto s2{prefix(MU_MSG_FIELD_ID_PRIO) +
std::string{1, to_char(prio)}};
writable_db().clear_synonyms(s1);
writable_db().clear_synonyms(s2);
writable_db().add_synonym(s1, s2);
}
}
time_t metadata_time_t(const std::string& key) const
@ -722,20 +717,18 @@ flag_val(char flagchar)
}
}
/* pre-calculate; optimization */
G_GNUC_CONST static const std::string&
prio_val(MuMsgPrio prio)
static const std::string&
prio_val(MessagePriority prio)
{
static const std::string pfx(prefix(MU_MSG_FIELD_ID_PRIO));
static const std::string low(pfx + std::string(1, mu_msg_prio_char(MU_MSG_PRIO_LOW))),
norm(pfx + std::string(1, mu_msg_prio_char(MU_MSG_PRIO_NORMAL))),
high(pfx + std::string(1, mu_msg_prio_char(MU_MSG_PRIO_HIGH)));
static const std::string low(pfx + std::string(1, to_char(MessagePriority::Low))),
norm(pfx + std::string(1, to_char(MessagePriority::Normal))),
high(pfx + std::string(1, to_char(MessagePriority::High)));
switch (prio) {
case MU_MSG_PRIO_LOW: return low;
case MU_MSG_PRIO_NORMAL: return norm;
case MU_MSG_PRIO_HIGH: return high;
case MessagePriority::Low: return low;
case MessagePriority::Normal: return norm;
case MessagePriority::High: return high;
default: g_return_val_if_reached(norm); return norm;
}
}
@ -766,7 +759,7 @@ add_terms_values_number(Xapian::Document& doc, MuMsg* msg, MuMsgFieldId mfid)
}
} else if (mfid == MU_MSG_FIELD_ID_PRIO)
add_term(doc, prio_val((MuMsgPrio)num));
add_term(doc, prio_val(static_cast<MessagePriority>(num)));
}
/* for string and string-list */

51
lib/tests/test-mu-msg.cc
View File

@ -94,9 +94,7 @@ test_mu_msg_01(void)
g_assert_cmpstr(mu_msg_get_header(msg, "Mailing-List"),
==,
"contact gcc-help-help@gcc.gnu.org; run by ezmlm");
g_assert_cmpuint(mu_msg_get_prio(msg), /* 'klub' */
==,
MU_MSG_PRIO_NORMAL);
g_assert_true(mu_msg_get_prio(msg) == Mu::MessagePriority::Normal);
g_assert_cmpuint(mu_msg_get_date(msg), ==, 1217530645);
i = 0;
@ -140,9 +138,8 @@ test_mu_msg_02(void)
g_assert_cmpstr(mu_msg_get_header(msg, "Errors-To"),
==,
"help-gnu-emacs-bounces+xxxx.klub=gmail.com@gnu.org");
g_assert_cmpuint(mu_msg_get_prio(msg), /* 'low' */
==,
MU_MSG_PRIO_LOW);
g_assert_true(mu_msg_get_prio(msg) /* 'low' */
== Mu::MessagePriority::Low);
g_assert_cmpuint(mu_msg_get_date(msg), ==, 1218051515);
i = 0;
@ -163,9 +160,8 @@ test_mu_msg_03(void)
g_assert_cmpstr(mu_msg_get_to(msg), ==, "Bilbo Baggins <bilbo@anotherexample.com>");
g_assert_cmpstr(mu_msg_get_subject(msg), ==, "Greetings from Lothlórien");
g_assert_cmpstr(mu_msg_get_from(msg), ==, "Frodo Baggins <frodo@example.com>");
g_assert_cmpuint(mu_msg_get_prio(msg), /* 'low' */
==,
MU_MSG_PRIO_NORMAL);
g_assert_true(mu_msg_get_prio(msg) /* 'low' */
== Mu::MessagePriority::Normal);
g_assert_cmpuint(mu_msg_get_date(msg), ==, 0);
g_assert_cmpstr(mu_msg_get_body_text(msg, MU_MSG_OPTION_NONE),
==,
@ -192,9 +188,8 @@ test_mu_msg_04(void)
g_assert_cmpstr(mu_msg_get_to(msg), ==, "George Custer <gac@example.com>");
g_assert_cmpstr(mu_msg_get_subject(msg), ==, "pics for you");
g_assert_cmpstr(mu_msg_get_from(msg), ==, "Sitting Bull <sb@example.com>");
g_assert_cmpuint(mu_msg_get_prio(msg), /* 'low' */
==,
MU_MSG_PRIO_NORMAL);
g_assert_true(mu_msg_get_prio(msg) /* 'low' */
== Mu::MessagePriority::Normal);
g_assert_cmpuint(mu_msg_get_date(msg), ==, 0);
g_assert_cmpuint(mu_msg_get_flags(msg), ==, MU_FLAG_HAS_ATTACH | MU_FLAG_UNREAD);
mu_msg_unref(msg);
@ -257,9 +252,8 @@ test_mu_msg_umlaut(void)
g_assert_cmpstr(mu_msg_get_to(msg), ==, "Helmut Kröger <hk@testmu.xxx>");
g_assert_cmpstr(mu_msg_get_subject(msg), ==, "Motörhead");
g_assert_cmpstr(mu_msg_get_from(msg), ==, "Mü <testmu@testmu.xx>");
g_assert_cmpuint(mu_msg_get_prio(msg), /* 'low' */
==,
MU_MSG_PRIO_NORMAL);
g_assert_true(mu_msg_get_prio(msg) /* 'low' */
== Mu::MessagePriority::Normal);
g_assert_cmpuint(mu_msg_get_date(msg), ==, 0);
mu_msg_unref(msg);
@ -366,9 +360,8 @@ test_mu_msg_tags(void)
==,
"Fere libenter homines id quod volunt credunt");
g_assert_cmpstr(mu_msg_get_from(msg), ==, "John Milton <jm@example.com>");
g_assert_cmpuint(mu_msg_get_prio(msg), /* 'low' */
==,
MU_MSG_PRIO_HIGH);
g_assert_true(mu_msg_get_prio(msg) /* 'low' */
== Mu::MessagePriority::High);
g_assert_cmpuint(mu_msg_get_date(msg), ==, 1217530645);
tags = mu_msg_get_tags(msg);
@ -414,9 +407,8 @@ test_mu_msg_comp_unix_programmer(void)
g_free(refs);
//"jimbo@slp53.sl.home (Jimbo Foobarcuux)";
g_assert_cmpuint(mu_msg_get_prio(msg), /* 'low' */
==,
MU_MSG_PRIO_NORMAL);
g_assert_true(mu_msg_get_prio(msg) /* 'low' */
== Mu::MessagePriority::Normal);
g_assert_cmpuint(mu_msg_get_date(msg), ==, 1299603860);
mu_msg_unref(msg);
@ -425,25 +417,17 @@ test_mu_msg_comp_unix_programmer(void)
static void
test_mu_str_prio_01(void)
{
g_assert_cmpstr(mu_msg_prio_name(MU_MSG_PRIO_LOW), ==, "low");
g_assert_cmpstr(mu_msg_prio_name(MU_MSG_PRIO_NORMAL), ==, "normal");
g_assert_cmpstr(mu_msg_prio_name(MU_MSG_PRIO_HIGH), ==, "high");
g_assert_true(message_priority_name(Mu::MessagePriority::Low) == "low");
g_assert_true(message_priority_name(Mu::MessagePriority::Normal) == "normal");
g_assert_true(message_priority_name(Mu::MessagePriority::High) == "high");
}
static gboolean
G_GNUC_UNUSED static gboolean
ignore_error(const char* log_domain, GLogLevelFlags log_level, const gchar* msg, gpointer user_data)
{
return FALSE; /* don't abort */
}
static void
test_mu_str_prio_02(void)
{
/* this must fail */
g_test_log_set_fatal_handler((GTestLogFatalFunc)ignore_error, NULL);
g_assert_cmpstr(mu_msg_prio_name((MuMsgPrio)666), ==, NULL);
}
static void
test_mu_str_display_contact(void)
{
@ -486,7 +470,6 @@ main(int argc, char* argv[])
/* mu_str_prio */
g_test_add_func("/mu-str/mu-str-prio-01", test_mu_str_prio_01);
g_test_add_func("/mu-str/mu-str-prio-02", test_mu_str_prio_02);
g_test_add_func("/mu-str/mu-str-display_contact", test_mu_str_display_contact);

1
lib/utils/mu-sexp.hh
View File

@ -76,6 +76,7 @@ struct Sexp {
throw Error(Error::Code::InvalidArgument, "symbol must be non-empty");
return Sexp{Type::Symbol, std::move(val)};
}
static Sexp make_symbol_sv(std::string_view val) { return make_symbol(std::string{val}); }
/**
*

5
mu/mu-cmd-find.cc
View File

@ -307,8 +307,9 @@ display_field(MuMsg* msg, MuMsgFieldId mfid)
case MU_MSG_FIELD_TYPE_INT:
if (mfid == MU_MSG_FIELD_ID_PRIO) {
val = mu_msg_get_field_numeric(msg, mfid);
return mu_msg_prio_name((MuMsgPrio)val);
const auto val = static_cast<char>(mu_msg_get_field_numeric(msg, mfid));
const auto prio = message_priority_from_char(val);
return message_priority_name_c_str(prio);
} else if (mfid == MU_MSG_FIELD_ID_FLAGS) {
val = mu_msg_get_field_numeric(msg, mfid);
return mu_str_flags_s((MuFlags)val);