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

many: update for lib/message updates 

Adapt to the new names / directory. Big commit, but mostly just very boring renaming.
This commit is contained in:
Dirk-Jan C. Binnema 2022-03-20 14:12:41 +02:00
parent 4c4fb1759f
commit f7c84006d7
32 changed files with 528 additions and 580 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -18,7 +18,7 @@
*/
#include "mu-guile-message.hh"
#include "libguile/scm.h"
#include "mu-message.hh"
#include "message/mu-message.hh"
#include <config.h>
#include <glib-object.h>
@ -36,10 +36,9 @@
#include <mu-msg-part.hh>
using namespace Mu;
using namespace Mu::Message;
/* pseudo field, not in Xapian */
constexpr auto MU_GUILE_MSG_FIELD_ID_TIMESTAMP = MessageField::id_size() + 1;
constexpr auto MU_GUILE_MSG_FIELD_ID_TIMESTAMP = Field::id_size() + 1;
/* some symbols */
static SCM SYMB_PRIO_LOW, SYMB_PRIO_NORMAL, SYMB_PRIO_HIGH;
@ -74,8 +73,8 @@ mu_guile_msg_to_scm(MuMsg* msg)
}
typedef struct {
MessageFlags flags;
SCM lst;
Flags flags;
SCM lst;
} FlagData;
#define MU_GUILE_INITIALIZED_OR_ERROR \
@ -109,9 +108,9 @@ static SCM
get_prio_scm(MuMsg* msg)
{
switch (mu_msg_get_prio(msg)) {
case MessagePriority::Low: return SYMB_PRIO_LOW;
case MessagePriority::Normal: return SYMB_PRIO_NORMAL;
case MessagePriority::High: return SYMB_PRIO_HIGH;
case Priority::Low: return SYMB_PRIO_LOW;
case Priority::Normal: return SYMB_PRIO_NORMAL;
case Priority::High: return SYMB_PRIO_HIGH;
default: g_return_val_if_reached(SCM_UNDEFINED);
}
@ -181,10 +180,10 @@ SCM_DEFINE(get_field,
if (field_id == MU_GUILE_MSG_FIELD_ID_TIMESTAMP)
return scm_from_uint((unsigned)mu_msg_get_timestamp(msgwrap->_msg));
const auto opt_id{message_field_id(static_cast<size_t>(field_id))};
SCM_ASSERT(!!opt_id, FIELD, SCM_ARG2, FUNC_NAME);
const auto field_opt{field_from_number(static_cast<size_t>(field_id))};
SCM_ASSERT(!!field_opt, FIELD, SCM_ARG2, FUNC_NAME);
switch (*opt_id) {
switch (field_opt->id) {
case Field::Id::Priority:
return get_prio_scm(msgwrap->_msg);
case Field::Id::Flags:
@ -197,16 +196,17 @@ SCM_DEFINE(get_field,
default: break;
}
switch (message_field(*opt_id).type) {
switch (field_opt->type) {
case Field::Type::String:
return mu_guile_scm_from_str(mu_msg_get_field_string(msgwrap->_msg, *opt_id));
return mu_guile_scm_from_str(mu_msg_get_field_string(msgwrap->_msg,
field_opt->id));
case Field::Type::ByteSize:
case Field::Type::TimeT:
return scm_from_uint(mu_msg_get_field_numeric(msgwrap->_msg, *opt_id));
return scm_from_uint(mu_msg_get_field_numeric(msgwrap->_msg, field_opt->id));
case Field::Type::Integer:
return scm_from_int(mu_msg_get_field_numeric(msgwrap->_msg, *opt_id));
return scm_from_int(mu_msg_get_field_numeric(msgwrap->_msg, field_opt->id));
case Field::Type::StringList:
return msg_string_list_field(msgwrap->_msg, *opt_id);
return msg_string_list_field(msgwrap->_msg, field_opt->id);
default: SCM_ASSERT(0, FIELD, SCM_ARG2, FUNC_NAME);
}
}
@ -472,7 +472,7 @@ define_symbols(void)
static void
define_vars(void)
{
message_field_for_each([](auto&& field){
field_for_each([](auto&& field){
const auto name{"mu:field:" + std::string{field.name}};
scm_c_define(name.c_str(), scm_from_uint(field.value_no()));
scm_c_export(name.c_str(), NULL);

46
lib/mu-contacts-cache.cc
View File

@ -44,7 +44,7 @@ struct EmailEqual {
}
};
using ContactUMap = std::unordered_map<const std::string, MessageContact, EmailHash, EmailEqual>;
using ContactUMap = std::unordered_map<const std::string, Contact, EmailHash, EmailEqual>;
struct ContactsCache::Private {
Private(const std::string& serialized, const StringVec& personal)
: contacts_{deserialize(serialized)},
@ -126,7 +126,7 @@ ContactsCache::Private::deserialize(const std::string& serialized) const
g_warning("error: '%s'", line.c_str());
continue;
}
MessageContact ci(parts[1], // email
Contact ci(parts[1], // email
std::move(parts[2]), // name
(time_t)g_ascii_strtoll(parts[4].c_str(), NULL, 10), // message_date
parts[3][0] == '1' ? true : false, // personal
@ -182,9 +182,9 @@ ContactsCache::dirty() const
return priv_->dirty_;
}
//const MessageContact
//const Contact
void
ContactsCache::add(MessageContact&& contact)
ContactsCache::add(Contact&& contact)
{
std::lock_guard<std::mutex> l_{priv_->mtx_};
@ -219,7 +219,7 @@ ContactsCache::add(MessageContact&& contact)
}
}
const MessageContact*
const Contact*
ContactsCache::_find(const std::string& email) const
{
std::lock_guard<std::mutex> l_{priv_->mtx_};
@ -251,19 +251,19 @@ ContactsCache::size() const
/**
* This is used for sorting the MessageContacts in order of relevance. A highly
* This is used for sorting the Contacts in order of relevance. A highly
* specific algorithm, but the details don't matter _too_ much.
*
* This is currently used for the ordering in mu-cfind and auto-completion in
* mu4e, if the various completion methods don't override it...
*/
constexpr auto RecentOffset{15 * 24 * 3600};
struct MessageContactLessThan {
MessageContactLessThan()
struct ContactLessThan {
ContactLessThan()
: recently_{::time({}) - RecentOffset} {}
bool operator()(const Mu::MessageContact& ci1, const Mu::MessageContact& ci2) const
bool operator()(const Mu::Contact& ci1, const Mu::Contact& ci2) const
{
// non-personal is less relevant.
if (ci1.personal != ci2.personal)
@ -286,8 +286,8 @@ struct MessageContactLessThan {
const time_t recently_;
};
using ContactSet = std::set<std::reference_wrapper<const MessageContact>,
MessageContactLessThan>;
using ContactSet = std::set<std::reference_wrapper<const Contact>,
ContactLessThan>;
void
ContactsCache::for_each(const EachContactFunc& each_contact) const
@ -338,22 +338,22 @@ test_mu_contacts_cache_base()
g_assert_true(contacts.empty());
g_assert_cmpuint(contacts.size(), ==, 0);
contacts.add(Mu::MessageContact("foo.bar@example.com",
contacts.add(Mu::Contact("foo.bar@example.com",
"Foo", {}, 12345));
g_assert_false(contacts.empty());
g_assert_cmpuint(contacts.size(), ==, 1);
contacts.add(Mu::MessageContact("cuux@example.com", "Cuux", {},
contacts.add(Mu::Contact("cuux@example.com", "Cuux", {},
54321));
g_assert_cmpuint(contacts.size(), ==, 2);
contacts.add(
Mu::MessageContact("foo.bar@example.com", "Foo", {}, 77777));
Mu::Contact("foo.bar@example.com", "Foo", {}, 77777));
g_assert_cmpuint(contacts.size(), ==, 2);
contacts.add(
Mu::MessageContact("Foo.Bar@Example.Com", "Foo", {}, 88888));
Mu::Contact("Foo.Bar@Example.Com", "Foo", {}, 88888));
g_assert_cmpuint(contacts.size(), ==, 2);
// note: replaces first.
@ -417,31 +417,31 @@ test_mu_contacts_cache_sort()
{ /* recent messages, older comes first */
Mu::ContactsCache ccache("");
ccache.add(Mu::MessageContact{"a@example.com", "a", now, true, 1000, 0});
ccache.add(Mu::MessageContact{"b@example.com", "b", now-1, true, 1000, 0});
ccache.add(Mu::Contact{"a@example.com", "a", now, true, 1000, 0});
ccache.add(Mu::Contact{"b@example.com", "b", now-1, true, 1000, 0});
assert_equal(result_chars(ccache), "ba");
}
{ /* non-recent messages, less frequent comes first */
Mu::ContactsCache ccache("");
ccache.add(Mu::MessageContact{"a@example.com", "a", now-2*RecentOffset, true, 1000, 0});
ccache.add(Mu::MessageContact{"b@example.com", "b", now-3*RecentOffset, true, 2000, 0});
ccache.add(Mu::Contact{"a@example.com", "a", now-2*RecentOffset, true, 1000, 0});
ccache.add(Mu::Contact{"b@example.com", "b", now-3*RecentOffset, true, 2000, 0});
assert_equal(result_chars(ccache), "ab");
}
{ /* non-personal comes first */
Mu::ContactsCache ccache("");
ccache.add(Mu::MessageContact{"a@example.com", "a", now-5*RecentOffset, true, 1000, 0});
ccache.add(Mu::MessageContact{"b@example.com", "b", now, false, 8000, 0});
ccache.add(Mu::Contact{"a@example.com", "a", now-5*RecentOffset, true, 1000, 0});
ccache.add(Mu::Contact{"b@example.com", "b", now, false, 8000, 0});
assert_equal(result_chars(ccache), "ba");
}
{ /* if all else fails, alphabetically */
Mu::ContactsCache ccache("");
ccache.add(Mu::MessageContact{"a@example.com", "a", now, false, 1000, 0});
ccache.add(Mu::MessageContact{"b@example.com", "b", now, false, 1000, 0});
ccache.add(Mu::Contact{"a@example.com", "a", now, false, 1000, 0});
ccache.add(Mu::Contact{"b@example.com", "b", now, false, 1000, 0});
g_assert_cmpuint(ccache.size(),==,2);
assert_equal(result_chars(ccache), "ab");
}

14
lib/mu-contacts-cache.hh
View File

@ -30,7 +30,7 @@
#include <inttypes.h>
#include <utils/mu-utils.hh>
#include "mu-message-contact.hh"
#include <message/mu-message.hh>
namespace Mu {
@ -53,19 +53,19 @@ public:
/**
* Add a contact
*
* @param contact a MessageContact object
* @param contact a Contact object
*
*/
void add(MessageContact&& contact);
void add(Contact&& contact);
/**
* Add a contacts sequemce
*
* @param contacts a MessageContact object sequence
* @param contacts a Contact object sequence
*
*/
void add(MessageContacts&& contacts) {
void add(Contacts&& contacts) {
for (auto&& contact: contacts)
add(std::move(contact));
}
@ -124,14 +124,14 @@ public:
*
* @return contact info, or {} if not found
*/
const MessageContact* _find(const std::string& email) const;
const Contact* _find(const std::string& email) const;
/**
* Prototype for a callable that receives a contact
*
* @param contact some contact
*/
using EachContactFunc = std::function<void(const MessageContact& contact_info)>;
using EachContactFunc = std::function<void(const Contact& contact_info)>;
/**
* Invoke some callable for each contact, in order of rank.

10
lib/mu-data.hh
View File

@ -24,7 +24,7 @@
#include <iostream>
#include <regex>
#include <mu-message.hh>
#include <message/mu-message.hh>
#include <utils/mu-utils.hh>
namespace Mu {
@ -38,11 +38,11 @@ struct Data {
Type type; /**< type of data */
std::string field; /**< full name of the field */
std::string prefix; /**< Xapian prefix for thef field */
Message::Field::Id id; /**< Xapian value no for the field */
Field::Id id; /**< The field */
protected:
Data(Type _type, const std::string& _field, const std::string& _prefix,
Message::Field::Id _id)
Field::Id _id)
: type(_type), field(_field), prefix(_prefix), id(_id)
{
}
@ -82,7 +82,7 @@ struct Range : public Data {
*/
Range(const std::string& _field,
const std::string& _prefix,
Message::Field::Id _id,
Field::Id _id,
const std::string& _lower,
const std::string& _upper)
:
@ -110,7 +110,7 @@ struct Value : public Data {
*/
Value(const std::string& _field,
const std::string& _prefix,
Message::Field::Id _id,
Field::Id _id,
const std::string& _value,
bool _phrase = false)
: Data(Value::Type::Value, _field, _prefix, _id), value(_value), phrase(_phrase)

29
lib/mu-maildir.cc
View File

@ -34,7 +34,6 @@
#include "glibconfig.h"
#include "mu-maildir.hh"
#include "mu-message-flags.hh"
#include "utils/mu-utils.hh"
#include "utils/mu-util.h"
@ -93,7 +92,7 @@ create_maildir(const std::string& path, mode_t mode)
return Ok();
}
static Mu::Result<void> /* create a noindex file if requested */
static Mu::Result<void> /* create a noindex file if requested */
create_noindex(const std::string& path)
{
const auto noindexpath{path + G_DIR_SEPARATOR_S MU_MAILDIR_NOINDEX_FILE};
@ -309,7 +308,7 @@ base_message_dir_file(const std::string& path)
Mu::Result<Mu::MessageFlags>
Mu::Result<Mu::Flags>
Mu::mu_maildir_flags_from_path(const std::string& path)
{ /*
* this gets us the source maildir filesystem path, the directory
@ -321,11 +320,11 @@ Mu::mu_maildir_flags_from_path(const std::string& path)
/* a message under new/ is just.. New. Filename is not considered */
if (dirfile->is_new)
return Ok(MessageFlags::New);
return Ok(Flags::New);
/* it's cur/ message, so parse the file name */
const auto parts{message_file_parts(dirfile->file)};
auto flags{message_flags_from_absolute_expr(parts.flags_suffix,
auto flags{flags_from_absolute_expr(parts.flags_suffix,
true/*ignore invalid*/)};
if (!flags)
return Err(Error{Error::Code::InvalidArgument,
@ -433,8 +432,8 @@ msg_move(const std::string& src, const std::string& dst)
Mu::Result<void>
Mu::mu_maildir_move_message(const std::string& oldpath,
const std::string& newpath,
bool ignore_dups)
const std::string& newpath,
bool ignore_dups)
{
if (oldpath == newpath) {
if (ignore_dups)
@ -468,7 +467,7 @@ reinvent_filename_base()
* @return the destion filename.
*/
static std::string
determine_dst_filename(const std::string& file, MessageFlags flags,
determine_dst_filename(const std::string& file, Flags flags,
bool new_name)
{
/* Recalculate a unique new base file name */
@ -478,12 +477,12 @@ determine_dst_filename(const std::string& file, MessageFlags flags,
/* for a New message, there are no flags etc.; so we only return the
* name sans suffix */
if (any_of(flags & MessageFlags::New))
if (any_of(flags & Flags::New))
return std::move(parts.base);
const auto flagstr{
message_flags_to_string(
message_flags_filter(
flags_to_string(
flags_filter(
flags, MessageFlagCategory::Mailfile))};
return parts.base + parts.separator + "2," + flagstr;
@ -497,7 +496,7 @@ static Mu::Result<void>
check_determine_target_params (const std::string& old_path,
const std::string& root_maildir_path,
const std::string& target_maildir,
MessageFlags newflags)
Flags newflags)
{
if (!g_path_is_absolute(old_path.c_str()))
return Err(Error{Error::Code::File,
@ -518,7 +517,7 @@ check_determine_target_params (const std::string& old_path,
"old-path must be below root-maildir (%s) (%s)",
old_path.c_str(), root_maildir_path.c_str()});
if (any_of(newflags & MessageFlags::New) && newflags != MessageFlags::New)
if (any_of(newflags & Flags::New) && newflags != Flags::New)
return Err(Error{Error::Code::File,
"if ::New is specified, "
"it must be the only flag"});
@ -530,7 +529,7 @@ Mu::Result<std::string>
Mu::mu_maildir_determine_target(const std::string& old_path,
const std::string& root_maildir_path,
const std::string& target_maildir,
MessageFlags newflags,
Flags newflags,
bool new_name)
{
/* sanity checks */
@ -557,7 +556,7 @@ Mu::mu_maildir_determine_target(const std::string& old_path,
/* and the complete path name. */
const auto subdir = std::invoke([&]()->std::string {
if (none_of(newflags & MessageFlags::New))
if (none_of(newflags & Flags::New))
return "cur";
else
return "new";

6
lib/mu-maildir.hh
View File

@ -27,7 +27,7 @@
#include <glib.h>
#include <time.h>
#include <sys/types.h> /* for mode_t */
#include <mu-message-flags.hh>
#include <message/mu-message.hh>
namespace Mu {
@ -81,7 +81,7 @@ Result<void> mu_maildir_clear_links(const std::string& dir);
*
* @return the message flags or an error
*/
Result<MessageFlags> mu_maildir_flags_from_path(const std::string& pathname);
Result<Flags> mu_maildir_flags_from_path(const std::string& pathname);
/**
* get the maildir for a certain message path, ie, the path *before*
@ -135,7 +135,7 @@ Result<std::string>
mu_maildir_determine_target(const std::string& old_path,
const std::string& root_maildir_path,
const std::string& target_maildir,
MessageFlags newflags,
Flags newflags,
bool new_name);
} // namespace Mu

11
lib/mu-msg-doc.cc
View File

@ -32,7 +32,6 @@
#include "utils/mu-xapian-utils.hh"
using namespace Mu;
using namespace Mu::Message;
struct Mu::MuMsgDoc {
MuMsgDoc(Xapian::Document* doc) : _doc(doc) {}
@ -75,7 +74,7 @@ Mu::mu_msg_doc_get_str_field(MuMsgDoc* self, Field::Id field_id)
return xapian_try(
[&] {
const auto value_no{message_field(field_id).value_no()};
const auto value_no{field_from_id(field_id).value_no()};
const std::string s(self->doc().get_value(value_no));
return s.empty() ? NULL : g_strdup(s.c_str());
},
@ -86,12 +85,12 @@ GSList*
Mu::mu_msg_doc_get_str_list_field(MuMsgDoc* self, Field::Id field_id)
{
g_return_val_if_fail(self, NULL);
g_return_val_if_fail(message_field(field_id).type == Field::Type::StringList, NULL);
g_return_val_if_fail(field_from_id(field_id).type == Field::Type::StringList, NULL);
return xapian_try(
[&] {
/* return a comma-separated string as a GSList */
const auto value_no{message_field(field_id).value_no()};
const auto value_no{field_from_id(field_id).value_no()};
const std::string s(self->doc().get_value(value_no));
return s.empty() ? NULL : mu_str_to_list(s.c_str(), ',', TRUE);
},
@ -102,11 +101,11 @@ gint64
Mu::mu_msg_doc_get_num_field(MuMsgDoc* self, Field::Id field_id)
{
g_return_val_if_fail(self, -1);
g_return_val_if_fail(message_field(field_id).is_numerical(), -1);
g_return_val_if_fail(field_from_id(field_id).is_numerical(), -1);
return xapian_try(
[&] {
const auto value_no{message_field(field_id).value_no()};
const auto value_no{field_from_id(field_id).value_no()};
const std::string s(self->doc().get_value(value_no));
if (s.empty())
return (gint64)0;

12
lib/mu-msg-doc.hh
View File

@ -55,35 +55,35 @@ void mu_msg_doc_destroy(MuMsgDoc* self);
* get a string parameter from the msgdoc
*
* @param self a MuMsgDoc instance
* @param mfid a Message::Field::Id for a string field
* @param mfid a Field::Id for a string field
*
* @return a string for the given field (see do_free), or NULL in case of error.
* free with g_free
*/
gchar* mu_msg_doc_get_str_field(MuMsgDoc* self, Message::Field::Id mfid) G_GNUC_WARN_UNUSED_RESULT;
gchar* mu_msg_doc_get_str_field(MuMsgDoc* self, Field::Id mfid) G_GNUC_WARN_UNUSED_RESULT;
/**
* get a string-list parameter from the msgdoc
*
* @param self a MuMsgDoc instance
* @param mfid a Message::Field::Id for a string-list field
* @param mfid a Field::Id for a string-list field
*
* @return a list for the given field (see do_free), or NULL in case
* of error. free with mu_str_free_list
*/
GSList* mu_msg_doc_get_str_list_field(MuMsgDoc* self, Message::Field::Id mfid) G_GNUC_WARN_UNUSED_RESULT;
GSList* mu_msg_doc_get_str_list_field(MuMsgDoc* self, Field::Id mfid) G_GNUC_WARN_UNUSED_RESULT;
/**
*
* get a numeric parameter from the msgdoc
*
* @param self a MuMsgDoc instance
* @param mfid a Message::Field::Id for a numeric field
* @param mfid a Field::Id for a numeric field
*
* @return the numerical value, or -1 in case of error. You'll need to
* cast this value to the actual type (e.g. time_t for Field::Id::Date)
*/
gint64 mu_msg_doc_get_num_field(MuMsgDoc* self, Message::Field::Id mfid);
gint64 mu_msg_doc_get_num_field(MuMsgDoc* self, Field::Id mfid);
} // namespace Mu

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

@ -37,7 +37,6 @@
#include "utils/mu-str.h"
using namespace Mu;
using namespace Mu::Message;
static gboolean
init_file_metadata(MuMsgFile* self, const char* path, const char* mdir, GError** err);
@ -346,15 +345,15 @@ looks_like_attachment(GMimeObject* part)
}
static void
msg_cflags_cb(GMimeObject* parent, GMimeObject* part, MessageFlags* flags)
msg_cflags_cb(GMimeObject* parent, GMimeObject* part, Flags* flags)
{
if (GMIME_IS_MULTIPART_SIGNED(part))
*flags |= MessageFlags::Signed;
*flags |= Flags::Signed;
/* FIXME: An encrypted part might be signed at the same time.
* In that case the signed flag is lost. */
if (GMIME_IS_MULTIPART_ENCRYPTED(part))
*flags |= MessageFlags::Encrypted;
*flags |= Flags::Encrypted;
/* smime */
if (GMIME_IS_APPLICATION_PKCS7_MIME(part)) {
@ -363,10 +362,10 @@ msg_cflags_cb(GMimeObject* parent, GMimeObject* part, MessageFlags* flags)
if (pkcs7) {
switch(pkcs7->smime_type) {
case GMIME_SECURE_MIME_TYPE_ENVELOPED_DATA:
*flags |= MessageFlags::Encrypted;
*flags |= Flags::Encrypted;
break;
case GMIME_SECURE_MIME_TYPE_SIGNED_DATA:
*flags |= MessageFlags::Signed;
*flags |= Flags::Signed;
break;
default:
break;
@ -374,20 +373,20 @@ msg_cflags_cb(GMimeObject* parent, GMimeObject* part, MessageFlags* flags)
}
}
if (any_of(*flags & MessageFlags::HasAttachment))
if (any_of(*flags & Flags::HasAttachment))
return;
if (!GMIME_IS_PART(part))
return;
if (looks_like_attachment(part))
*flags |= MessageFlags::HasAttachment;
*flags |= Flags::HasAttachment;
}
static MessageFlags
static Flags
get_content_flags(MuMsgFile* self)
{
MessageFlags flags{MessageFlags::None};
Flags flags{Flags::None};
if (GMIME_IS_MESSAGE(self->_mime_msg)) {
/* toplevel */
@ -401,27 +400,27 @@ get_content_flags(MuMsgFile* self)
char *ml{get_mailing_list(self)};
if (ml) {
flags |= MessageFlags::MailingList;
flags |= Flags::MailingList;
g_free(ml);
}
return flags;
}
static MessageFlags
static Flags
get_flags(MuMsgFile* self)
{
g_return_val_if_fail(self, MessageFlags::None);
g_return_val_if_fail(self, Flags::None);
auto flags{mu_maildir_flags_from_path(self->_path)
.value_or(MessageFlags::None)};
.value_or(Flags::None)};
flags |= get_content_flags(self);
/* pseudo-flag --> unread means either NEW or NOT SEEN, just
* for searching convenience */
if (any_of(flags & MessageFlags::New) ||
none_of(flags & MessageFlags::Seen))
flags |= MessageFlags::Unread;
if (any_of(flags & Flags::New) ||
none_of(flags & Flags::Seen))
flags |= Flags::Unread;
return flags;
}
@ -433,41 +432,41 @@ get_size(MuMsgFile* self)
return self->_size;
}
static MessagePriority
static Priority
parse_prio_str(const char* priostr)
{
int i;
struct {
const char* _str;
MessagePriority _prio;
} str_prio[] = {{"high", MessagePriority::High},
{"1", MessagePriority::High},
{"2", MessagePriority::High},
Priority _prio;
} str_prio[] = {{"high", Priority::High},
{"1", Priority::High},
{"2", Priority::High},
{"normal", MessagePriority::Normal},
{"3", MessagePriority::Normal},
{"normal", Priority::Normal},
{"3", Priority::Normal},
{"low", MessagePriority::Low},
{"list", MessagePriority::Low},
{"bulk", MessagePriority::Low},
{"4", MessagePriority::Low},
{"5", MessagePriority::Low}};
{"low", Priority::Low},
{"list", Priority::Low},
{"bulk", Priority::Low},
{"4", Priority::Low},
{"5", Priority::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 MessagePriority::Normal;
return Priority::Normal;
}
static MessagePriority
static Priority
get_prio(MuMsgFile* self)
{
GMimeObject* obj;
const char* priostr;
g_return_val_if_fail(self, MessagePriority::Normal);
g_return_val_if_fail(self, Priority::Normal);
obj = GMIME_OBJECT(self->_mime_msg);
@ -477,7 +476,7 @@ get_prio(MuMsgFile* self)
if (!priostr)
priostr = g_mime_object_get_header(obj, "Importance");
if (!priostr)
return MessagePriority::Normal;
return Priority::Normal;
else
return parse_prio_str(priostr);
}
@ -713,7 +712,7 @@ char*
Mu::mu_msg_file_get_str_field(MuMsgFile* self, Field::Id field_id, gboolean* do_free)
{
g_return_val_if_fail(self, NULL);
g_return_val_if_fail(message_field(field_id).is_string(), NULL);
g_return_val_if_fail(field_from_id(field_id).is_string(), NULL);
*do_free = FALSE; /* default */
@ -738,7 +737,7 @@ Mu::mu_msg_file_get_str_field(MuMsgFile* self, Field::Id field_id, gboolean* do_
case Field::Id::BodyHtml: /* use mu_msg_get_body_html */
case Field::Id::EmbeddedText:
g_warning("%*s is not retrievable through: %s",
STR_V(message_field(field_id).name), __func__);
STR_V(field_from_id(field_id).name), __func__);
return NULL;
default: g_return_val_if_reached(NULL);
@ -749,7 +748,7 @@ GSList*
Mu::mu_msg_file_get_str_list_field(MuMsgFile* self, Field::Id field_id)
{
g_return_val_if_fail(self, NULL);
g_return_val_if_fail(message_field(field_id).is_string_list(), NULL);
g_return_val_if_fail(field_from_id(field_id).is_string_list(), NULL);
switch (field_id) {
case Field::Id::References: return get_references(self);
@ -762,7 +761,7 @@ gint64
Mu::mu_msg_file_get_num_field(MuMsgFile* self, const Field::Id field_id)
{
g_return_val_if_fail(self, -1);
g_return_val_if_fail(message_field(field_id).is_numerical(), -1);
g_return_val_if_fail(field_from_id(field_id).is_numerical(), -1);
switch (field_id) {
case Field::Id::Date: {

6
lib/mu-msg-file.hh
View File

@ -70,7 +70,7 @@ char* mu_msg_file_get_header(MuMsgFile* self, const char* header);
* @return a string, or NULL
*/
char* mu_msg_file_get_str_field(MuMsgFile* self,
Message::Field::Id msfid,
Field::Id msfid,
gboolean* do_free) G_GNUC_WARN_UNUSED_RESULT;
/**
@ -82,7 +82,7 @@ char* mu_msg_file_get_str_field(MuMsgFile* self,
* @return a GSList*, or NULL; free with mu_str_free_list
*/
GSList* mu_msg_file_get_str_list_field(MuMsgFile* self,
Message::Field::Id msfid) G_GNUC_WARN_UNUSED_RESULT;
Field::Id msfid) G_GNUC_WARN_UNUSED_RESULT;
/**
* get a numeric value for this message -- the return value should be
@ -93,7 +93,7 @@ GSList* mu_msg_file_get_str_list_field(MuMsgFile* self,
*
* @return the numeric value, or -1 in case of error
*/
gint64 mu_msg_file_get_num_field(MuMsgFile* self, Message::Field::Id mfid);
gint64 mu_msg_file_get_num_field(MuMsgFile* self, Field::Id mfid);
} // namespace Mu

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

@ -19,7 +19,7 @@
#include <string.h>
#include <ctype.h>
#include "mu-message.hh"
#include "message/mu-message.hh"
#include "mu-query-results.hh"
#include "utils/mu-str.h"
#include "mu-msg.hh"
@ -27,7 +27,6 @@
#include "mu-maildir.hh"
using namespace Mu;
using namespace Mu::Message;
static void
add_prop_nonempty(Sexp::List& list, const char* elm, const GSList* str_lst)
@ -51,7 +50,7 @@ add_prop_nonempty(Sexp::List& list, const char* name, const char* str)
static Mu::Sexp
make_contact_sexp(const MessageContact& contact)
make_contact_sexp(const Contact& contact)
{
return Sexp::make_list(
/* name */
@ -84,7 +83,7 @@ add_list_post(Sexp::List& list, MuMsg* msg)
if (g_regex_match(rx, list_post, (GRegexMatchFlags)0, &minfo)) {
auto address = (char*)g_match_info_fetch(minfo, 1);
list.add_prop(":list-post", make_contact_sexp(MessageContact{address}));
list.add_prop(":list-post", make_contact_sexp(Contact{address}));
g_free(address);
}
@ -359,7 +358,7 @@ Mu::msg_to_sexp_list(MuMsg* msg, unsigned docid, MuMsgOptions opts)
add_prop_nonempty(items, ":maildir", mu_msg_get_maildir(msg));
items.add_prop(":priority",
Sexp::make_symbol_sv(message_priority_name(mu_msg_get_prio(msg))));
Sexp::make_symbol_sv(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 */

55
lib/mu-msg.cc
View File

@ -32,7 +32,6 @@
#include "gmime/gmime-message.h"
#include "mu-message-contact.hh"
#include "mu-msg-priv.hh" /* include before mu-msg.h */
#include "mu-msg.hh"
#include "utils/mu-str.h"
@ -40,7 +39,6 @@
#include "mu-maildir.hh"
using namespace Mu;
using namespace Mu::Message;
/* note, we do the gmime initialization here rather than in
* mu-runtime, because this way we don't need mu-runtime for simple
@ -250,9 +248,9 @@ get_str_list_field(MuMsg* self, Field::Id field_id)
val = NULL;
if (self->_doc &&
any_of(message_field(field_id).flags & Field::Flag::Value))
any_of(field_from_id(field_id).flags & Field::Flag::Value))
val = mu_msg_doc_get_str_list_field(self->_doc, field_id);
else if (any_of(message_field(field_id).flags & Field::Flag::GMime)) {
else if (any_of(field_from_id(field_id).flags & Field::Flag::GMime)) {
/* if we don't have a file object yet, we need to
* create it from the file on disk */
if (!mu_msg_load_msg_file(self, NULL))
@ -273,10 +271,10 @@ get_str_field(MuMsg* self, Field::Id field_id)
val = NULL;
if (self->_doc &&
any_of(message_field(field_id).flags & Field::Flag::Value))
any_of(field_from_id(field_id).flags & Field::Flag::Value))
val = mu_msg_doc_get_str_field(self->_doc, field_id);
else if (any_of(message_field(field_id).flags & Field::Flag::GMime)) {
else if (any_of(field_from_id(field_id).flags & Field::Flag::GMime)) {
/* if we don't have a file object yet, we need to
* create it from the file on disk */
if (!mu_msg_load_msg_file(self, NULL))
@ -292,7 +290,7 @@ static gint64
get_num_field(MuMsg* self, Field::Id field_id)
{
if (self->_doc &&
any_of(message_field(field_id).flags & Field::Flag::Value))
any_of(field_from_id(field_id).flags & Field::Flag::Value))
return mu_msg_doc_get_num_field(self->_doc, field_id);
/* if we don't have a file object yet, we need to
@ -423,11 +421,11 @@ Mu::mu_msg_get_date(MuMsg* self)
return (time_t)get_num_field(self, Field::Id::Date);
}
MessageFlags
Flags
Mu::mu_msg_get_flags(MuMsg* self)
{
g_return_val_if_fail(self, MessageFlags::None);
return static_cast<MessageFlags>(get_num_field(self, Field::Id::Flags));
g_return_val_if_fail(self, Flags::None);
return static_cast<Flags>(get_num_field(self, Field::Id::Flags));
}
size_t
@ -437,12 +435,12 @@ Mu::mu_msg_get_size(MuMsg* self)
return (size_t)get_num_field(self, Field::Id::Size);
}
Mu::MessagePriority
Mu::Priority
Mu::mu_msg_get_prio(MuMsg* self)
{
g_return_val_if_fail(self, MessagePriority{});
g_return_val_if_fail(self, Priority{});
return message_priority_from_char(
return priority_from_char(
static_cast<char>(get_num_field(self, Field::Id::Priority)));
}
@ -619,12 +617,12 @@ Mu::mu_msg_get_field_numeric(MuMsg* self, Field::Id field_id)
}
static Mu::MessageContacts
static Mu::Contacts
get_all_contacts(MuMsg *self)
{
MessageContacts contacts;
Contacts contacts;
message_field_for_each([&](const auto& field){
field_for_each([&](const auto& field){
if (!field.is_contact())
return;
auto type_contacts{mu_msg_get_contacts(self, field.id)};
@ -637,27 +635,27 @@ get_all_contacts(MuMsg *self)
return contacts;
}
Mu::MessageContacts
Mu::mu_msg_get_contacts(MuMsg *self, std::optional<MessageField::Id> field_id)
Mu::Contacts
Mu::mu_msg_get_contacts(MuMsg *self, std::optional<Field::Id> field_id)
{
typedef const char*(*AddressFunc)(MuMsg*);
using AddressInfo = std::pair<GMimeAddressType, AddressFunc>;
g_return_val_if_fail(self, MessageContacts{});
g_return_val_if_fail(!field_id || message_field(*field_id).is_contact(),
MessageContacts{});
g_return_val_if_fail(self, Contacts{});
g_return_val_if_fail(!field_id || field_from_id(*field_id).is_contact(),
Contacts{});
if (!field_id)
return get_all_contacts(self);
const auto info = std::invoke([&]()->AddressInfo {
switch (*field_id) {
case MessageField::Id::From:
case Field::Id::From:
return { GMIME_ADDRESS_TYPE_FROM, mu_msg_get_from };
case MessageField::Id::To:
case Field::Id::To:
return { GMIME_ADDRESS_TYPE_TO, mu_msg_get_to };
case MessageField::Id::Cc:
case Field::Id::Cc:
return { GMIME_ADDRESS_TYPE_CC, mu_msg_get_cc };
case MessageField::Id::Bcc:
case Field::Id::Bcc:
return { GMIME_ADDRESS_TYPE_BCC, mu_msg_get_bcc };
default:
throw std::logic_error("bug");
@ -668,14 +666,13 @@ Mu::mu_msg_get_contacts(MuMsg *self, std::optional<MessageField::Id> field_id)
if (self->_file) {
if (auto&& lst{g_mime_message_get_addresses(
self->_file->_mime_msg, info.first)}; lst)
return make_message_contacts(lst, *field_id, mdate);
return make_contacts(lst, *field_id, mdate);
} else if (info.second) {
if (auto&& lst_str{info.second(self)}; lst_str)
return make_message_contacts(lst_str, *field_id, mdate);
return make_contacts(lst_str, *field_id, mdate);
}
return {};
}
@ -697,7 +694,7 @@ bool
Mu::mu_msg_move_to_maildir(MuMsg* self,
const std::string& root_maildir_path,
const std::string& target_maildir,
MessageFlags flags,
Flags flags,
bool ignore_dups,
bool new_name,
GError** err)

22
lib/mu-msg.hh
View File

@ -22,7 +22,7 @@
#include <utils/mu-result.hh>
#include <mu-message.hh>
#include <message/mu-message.hh>
#include <utils/mu-util.h>
#include <utils/mu-utils.hh>
@ -295,10 +295,10 @@ time_t mu_msg_get_date(MuMsg* msg);
*
* @param msg valid MuMsg* instance
*
* @return the file/content flags as logically OR'd #Mu::MessageFlags.
* @return the file/content flags as logically OR'd #Mu::Flags.
* Non-standard flags are ignored.
*/
MessageFlags mu_msg_get_flags(MuMsg* msg);
Flags mu_msg_get_flags(MuMsg* msg);
/**
* get the file size in bytes of this message
@ -317,7 +317,7 @@ size_t mu_msg_get_size(MuMsg* msg);
*
* @return a string that should not be freed
*/
const char* mu_msg_get_field_string(MuMsg* msg, Message::Field::Id mfid);
const char* mu_msg_get_field_string(MuMsg* msg, Field::Id mfid);
/**
* get some field value as string-list
@ -327,7 +327,7 @@ const char* mu_msg_get_field_string(MuMsg* msg, Message::Field::Id mfid);
*
* @return a list that should not be freed
*/
const GSList* mu_msg_get_field_string_list(MuMsg* self, Message::Field::Id mfid);
const GSList* mu_msg_get_field_string_list(MuMsg* self, Field::Id mfid);
/**
* get some field value as string
@ -337,7 +337,7 @@ const GSList* mu_msg_get_field_string_list(MuMsg* self, Message::Field::Id mfid)
*
* @return a string that should not be freed
*/
gint64 mu_msg_get_field_numeric(MuMsg* msg, Message::Field::Id mfid);
gint64 mu_msg_get_field_numeric(MuMsg* msg, Field::Id mfid);
/**
* get the message priority for this message. The X-Priority, X-MSMailPriority,
@ -348,7 +348,7 @@ gint64 mu_msg_get_field_numeric(MuMsg* msg, Message::Field::Id mfid);
*
* @return the message priority
*/
MessagePriority mu_msg_get_prio(MuMsg* msg);
Priority mu_msg_get_prio(MuMsg* msg);
/**
* get the timestamp (mtime) for the file containing this message
@ -401,7 +401,7 @@ const GSList* mu_msg_get_tags(MuMsg* self);
* @return negative if m1 is smaller, positive if m1 is smaller, 0 if
* they are equal
*/
int mu_msg_cmp(MuMsg* m1, MuMsg* m2, Message::Field::Id mfid);
int mu_msg_cmp(MuMsg* m1, MuMsg* m2, Field::Id mfid);
/**
* check whether there there's a readable file behind this message
@ -433,7 +433,7 @@ gboolean mu_msg_is_readable(MuMsg* self);
bool mu_msg_move_to_maildir(MuMsg* msg,
const std::string& root_maildir_path,
const std::string& target_maildir,
MessageFlags flags,
Flags flags,
bool ignore_dups,
bool new_name,
GError** err);
@ -445,8 +445,8 @@ bool mu_msg_move_to_maildir(MuMsg* msg,
*
* @return a sequence
*/
Mu::MessageContacts mu_msg_get_contacts (MuMsg *self,
std::optional<MessageField::Id> field_id={});
Mu::Contacts mu_msg_get_contacts (MuMsg *self,
std::optional<Field::Id> field_id={});
/**
* create a 'display contact' from an email header To/Cc/Bcc/From-type address
* ie., turn

34
lib/mu-parser.cc
View File

@ -28,7 +28,6 @@
#include "mu-message.hh"
using namespace Mu;
using namespace Mu::Message;
// 3 precedence levels: units (NOT,()) > factors (OR) > terms (AND)
@ -95,15 +94,15 @@ struct Parser::Private {
static std::string
process_value(const std::string& field, const std::string& value)
{
const auto id_opt{message_field_id(field)};
const auto id_opt{field_from_name(field)};
if (id_opt) {
switch (*id_opt) {
switch (id_opt->id) {
case Field::Id::Priority: {
if (!value.empty())
return std::string(1, value[0]);
} break;
case Field::Id::Flags:
if (const auto info{message_flag_info(value)}; info)
if (const auto info{flag_info(value)}; info)
return std::string(1, info->shortcut_lower());
break;
default:
@ -117,7 +116,7 @@ process_value(const std::string& field, const std::string& value)
static void
add_field(std::vector<FieldInfo>& fields, Field::Id field_id)
{
const auto field{message_field(field_id)};
const auto field{field_from_id(field_id)};
if (!field.shortcut)
return; // can't be searched
@ -147,8 +146,8 @@ process_field(const std::string& field_str, Parser::Flags flags)
add_field(fields, Field::Id::From);
add_field(fields, Field::Id::Subject);
add_field(fields, Field::Id::BodyText);
} else if (const auto id_opt{message_field_id(field_str)}; id_opt)
add_field(fields, *id_opt);
} else if (const auto field_opt{field_from_name(field_str)}; field_opt)
add_field(fields, field_opt->id);
return fields;
}
@ -156,10 +155,10 @@ process_field(const std::string& field_str, Parser::Flags flags)
static bool
is_range_field(const std::string& field_str)
{
if (const auto field_id_opt{message_field_id(field_str)}; !field_id_opt)
if (const auto field_opt{field_from_name(field_str)}; !field_opt)
return false;
else
return message_field(*field_id_opt).is_range();
return field_opt->is_range();
}
struct MyRange {
@ -171,17 +170,17 @@ static MyRange
process_range(const std::string& field_str,
const std::string& lower, const std::string& upper)
{
const auto id_opt{message_field_id(field_str)};
if (!id_opt)
const auto field_opt{field_from_name(field_str)};
if (!field_opt)
return {lower, upper};
std::string l2 = lower;
std::string u2 = upper;
if (*id_opt == Field::Id::Date) {
if (field_opt->id == Field::Id::Date) {
l2 = Mu::date_to_time_t_string(lower, true);
u2 = Mu::date_to_time_t_string(upper, false);
} else if (*id_opt == Field::Id::Size) {
} else if (field_opt->id == Field::Id::Size) {
l2 = Mu::size_to_string(lower, true);
u2 = Mu::size_to_string(upper, false);
}
@ -193,14 +192,13 @@ std::vector<std::string>
Parser::Private::process_regex(const std::string& field_str,
const std::regex& rx) const
{
const auto id_opt{message_field_id(field_str)};
if (!id_opt)
const auto field_opt{field_from_name(field_str)};
if (!field_opt)
return {};
const auto field{message_field(*id_opt)};
const auto prefix{field.xapian_term()};
const auto prefix{field_opt->xapian_term()};
std::vector<std::string> terms;
store_.for_each_term(field.id, [&](auto&& str) {
store_.for_each_term(field_opt->id, [&](auto&& str) {
if (std::regex_search(str.c_str() + 1, rx)) // avoid copy
terms.emplace_back(str);
return true;

4
lib/mu-query-match-deciders.cc
View File

@ -23,7 +23,7 @@
#include "utils/mu-option.hh"
using namespace Mu;
using namespace Mu::Message;
// We use a MatchDecider to gather information about the matches, and decide
// whether to include them in the results.
@ -98,7 +98,7 @@ struct MatchDecider : public Xapian::MatchDecider {
private:
Option<std::string> opt_string(const Xapian::Document& doc, Field::Id id) const noexcept {
const auto value_no{message_field(id).value_no()};
const auto value_no{field_from_id(id).value_no()};
std::string val = xapian_try([&] { return doc.get_value(value_no); }, std::string{""});
if (val.empty())
return Nothing;

16
lib/mu-query-results.hh
View File

@ -219,7 +219,7 @@ public:
*/
Option<std::string> message_id() const noexcept
{
return opt_string(Message::Field::Id::MessageId);
return opt_string(Field::Id::MessageId);
}
/**
@ -230,7 +230,7 @@ public:
*/
Option<std::string> thread_id() const noexcept
{
return opt_string(Message::Field::Id::ThreadId);
return opt_string(Field::Id::ThreadId);
}
/**
@ -239,7 +239,7 @@ public:
*
* @return a filesystem path
*/
Option<std::string> path() const noexcept { return opt_string(Message::Field::Id::Path); }
Option<std::string> path() const noexcept { return opt_string(Field::Id::Path); }
/**
* Get the date for the document (message) the iterator is pointing at.
@ -247,7 +247,7 @@ public:
*
* @return a filesystem path
*/
Option<std::string> date() const noexcept { return opt_string(Message::Field::Id::Date); }
Option<std::string> date() const noexcept { return opt_string(Field::Id::Date); }
/**
* Get the file-system path for the document (message) this iterator is
@ -255,7 +255,7 @@ public:
*
* @return the subject
*/
Option<std::string> subject() const noexcept { return opt_string(Message::Field::Id::Subject); }
Option<std::string> subject() const noexcept { return opt_string(Field::Id::Subject); }
/**
* Get the references for the document (messages) this is iterator is
@ -266,7 +266,7 @@ public:
*/
std::vector<std::string> references() const noexcept
{
return split(opt_string(Message::Field::Id::References).value_or(""), ",");
return split(opt_string(Field::Id::References).value_or(""), ",");
}
/**
@ -276,10 +276,10 @@ public:
*
* @return the value
*/
Option<std::string> opt_string(Message::Field::Id id) const noexcept
Option<std::string> opt_string(Field::Id id) const noexcept
{
std::string empty;
const auto value_no{message_field(id).value_no()};
const auto value_no{field_from_id(id).value_no()};
std::string val = xapian_try([&] {return document().get_value(value_no);}, empty);
if (val.empty())
return Nothing;

68
lib/mu-query-threads.cc
View File

@ -18,7 +18,7 @@
*/
#include "mu-query-threads.hh"
#include "mu-message-fields.hh"
#include <message/mu-message.hh>
#include <set>
#include <unordered_set>
@ -385,10 +385,10 @@ subject_matches(const std::string& sub1, const std::string& sub2)
static bool
update_container(Container& container,
bool descending,
ThreadPath& tpath,
size_t seg_size,
const std::string& prev_subject = "")
bool descending,
ThreadPath& tpath,
size_t seg_size,
const std::string& prev_subject = "")
{
if (!container.children.empty()) {
Container* first = container.children.front();
@ -433,10 +433,10 @@ update_container(Container& container,
static void
update_containers(Containers& children,
bool descending,
ThreadPath& tpath,
size_t seg_size,
std::string& prev_subject)
bool descending,
ThreadPath& tpath,
size_t seg_size,
std::string& prev_subject)
{
size_t idx{0};
@ -606,13 +606,13 @@ Mu::calculate_threads(Mu::QueryResults& qres, bool descending)
struct MockQueryResult {
MockQueryResult(const std::string& message_id_arg,
const std::string& date_arg,
const std::vector<std::string>& refs_arg = {})
const std::string& date_arg,
const std::vector<std::string>& refs_arg = {})
: message_id_{message_id_arg}, date_{date_arg}, refs_{refs_arg}
{
}
MockQueryResult(const std::string& message_id_arg,
const std::vector<std::string>& refs_arg = {})
const std::vector<std::string>& refs_arg = {})
: MockQueryResult(message_id_arg, "", refs_arg)
{
}
@ -669,9 +669,9 @@ static void
test_sort_ascending()
{
auto results = MockQueryResults{MockQueryResult{"m1", "1", {"m2"}},
MockQueryResult{"m2", "2", {"m3"}},
MockQueryResult{"m3", "3", {}},
MockQueryResult{"m4", "4", {}}};
MockQueryResult{"m2", "2", {"m3"}},
MockQueryResult{"m3", "3", {}},
MockQueryResult{"m4", "4", {}}};
calculate_threads(results, false);
@ -682,14 +682,14 @@ static void
test_sort_descending()
{
auto results = MockQueryResults{MockQueryResult{"m1", "1", {"m2"}},
MockQueryResult{"m2", "2", {"m3"}},
MockQueryResult{"m3", "3", {}},
MockQueryResult{"m4", "4", {}}};
MockQueryResult{"m2", "2", {"m3"}},
MockQueryResult{"m3", "3", {}},
MockQueryResult{"m4", "4", {}}};
calculate_threads(results, true);
assert_thread_paths(results,
{{"m1", "1:f:f:z"}, {"m2", "1:f:z"}, {"m3", "1:z"}, {"m4", "0:z"}});
{{"m1", "1:f:f:z"}, {"m2", "1:f:z"}, {"m3", "1:z"}, {"m4", "0:z"}});
}
static void
@ -705,7 +705,7 @@ test_id_table_inconsistent()
calculate_threads(results, false);
assert_thread_paths(results,
{
{
{"m2", "0"},
{"m1", "0:0"},
{"m3", "1"},
@ -730,7 +730,7 @@ test_dups_dup_last()
calculate_threads(results, false);
assert_thread_paths(results,
{
{
{"/path1", "0"},
{"/path2", "0:0"},
});
@ -755,7 +755,7 @@ test_dups_dup_first()
calculate_threads(results, false);
assert_thread_paths(results,
{
{
{"/path2", "0"},
{"/path1", "0:0"},
});
@ -773,7 +773,7 @@ test_do_not_prune_root_empty_with_children()
calculate_threads(results, false);
assert_thread_paths(results,
{
{
{"x1", "0:0"},
{"x2", "0:1"},
});
@ -790,7 +790,7 @@ test_prune_root_empty_with_child()
calculate_threads(results, false);
assert_thread_paths(results,
{
{
{"m1", "0"},
});
}
@ -807,7 +807,7 @@ test_prune_empty_with_children()
calculate_threads(results, false);
assert_thread_paths(results,
{
{
{"m1", "0:0"},
{"m2", "0:1"},
});
@ -828,7 +828,7 @@ test_thread_info_ascending()
calculate_threads(results, false);
assert_thread_paths(results,
{
{
{"m2", "0"}, // 2
{"m4", "0:0"}, // 2
{"m3", "0:1"}, // 3
@ -840,11 +840,11 @@ test_thread_info_ascending()
g_assert_true(results[0].query_match().has_flag(QueryMatch::Flags::Root));
g_assert_true(results[1].query_match().has_flag(QueryMatch::Flags::Root |
QueryMatch::Flags::HasChild));
QueryMatch::Flags::HasChild));
g_assert_true(results[2].query_match().has_flag(QueryMatch::Flags::Last));
g_assert_true(results[3].query_match().has_flag(QueryMatch::Flags::First));
g_assert_true(results[4].query_match().has_flag(QueryMatch::Flags::Orphan |
QueryMatch::Flags::First));
QueryMatch::Flags::First));
g_assert_true(
results[5].query_match().has_flag(QueryMatch::Flags::Orphan | QueryMatch::Flags::Last));
}
@ -864,7 +864,7 @@ test_thread_info_descending()
calculate_threads(results, true /*descending*/);
assert_thread_paths(results,
{
{
{"m1", "1:z"}, // 5
{"m2", "2:z"}, // 2
{"m4", "2:f:z"}, // 2
@ -875,14 +875,14 @@ test_thread_info_descending()
});
g_assert_true(results[0].query_match().has_flag(QueryMatch::Flags::Root));
g_assert_true(results[1].query_match().has_flag(QueryMatch::Flags::Root |
QueryMatch::Flags::HasChild));
QueryMatch::Flags::HasChild));
g_assert_true(results[2].query_match().has_flag(QueryMatch::Flags::Last));
g_assert_true(results[3].query_match().has_flag(QueryMatch::Flags::First));
g_assert_true(
results[4].query_match().has_flag(QueryMatch::Flags::Orphan | QueryMatch::Flags::Last));
g_assert_true(results[5].query_match().has_flag(QueryMatch::Flags::Orphan |
QueryMatch::Flags::First));
QueryMatch::Flags::First));
}
int
@ -898,11 +898,11 @@ try {
g_test_add_func("/threader/dups/dup-first", test_dups_dup_first);
g_test_add_func("/threader/prune/do-not-prune-root-empty-with-children",
test_do_not_prune_root_empty_with_children);
test_do_not_prune_root_empty_with_children);
g_test_add_func("/threader/prune/prune-root-empty-with-child",
test_prune_root_empty_with_child);
test_prune_root_empty_with_child);
g_test_add_func("/threader/prune/prune-empty-with-children",
test_prune_empty_with_children);
test_prune_empty_with_children);
g_test_add_func("/threader/thread-info/ascending", test_thread_info_ascending);
g_test_add_func("/threader/thread-info/descending", test_thread_info_descending);

11
lib/mu-query.cc
View File

@ -35,7 +35,6 @@
#include <mu-xapian.hh>
using namespace Mu;
using namespace Mu::Message;
struct Query::Private {
Private(const Store& store) : store_{store}, parser_{store_} {}
@ -77,7 +76,7 @@ Query::~Query() = default;
static Xapian::Enquire&
sort_enquire(Xapian::Enquire& enq, Field::Id sortfield_id, QueryFlags qflags)
{
const auto value_no{message_field(sortfield_id).value_no()};
const auto value_no{field_from_id(sortfield_id).value_no()};
enq.set_sort_by_value(value_no, any_of(qflags & QueryFlags::Descending));
return enq;
@ -115,7 +114,7 @@ Query::Private::make_related_enquire(const StringSet& thread_ids,
Xapian::Enquire enq{store_.database()};
std::vector<Xapian::Query> qvec;
for (auto&& t : thread_ids)
qvec.emplace_back(message_field(Field::Id::ThreadId).xapian_term(t));
qvec.emplace_back(field_from_id(Field::Id::ThreadId).xapian_term(t));
Xapian::Query qr{Xapian::Query::OP_OR, qvec.begin(), qvec.end()};
enq.set_query(qr);
@ -187,7 +186,7 @@ Query::Private::run_singular(const std::string& expr,
static Option<std::string>
opt_string(const Xapian::Document& doc, Field::Id id) noexcept
{
const auto value_no{message_field(id).value_no()};
const auto value_no{field_from_id(id).value_no()};
std::string val =
xapian_try([&] { return doc.get_value(value_no); }, std::string{""});
if (val.empty())
@ -245,7 +244,7 @@ Query::Private::run_related(const std::string& expr,
Option<QueryResults>
Query::Private::run(const std::string& expr,
std::optional<Message::Field::Id> sortfield_id, QueryFlags qflags,
std::optional<Field::Id> sortfield_id, QueryFlags qflags,
size_t maxnum) const
{
const auto eff_maxnum{maxnum == 0 ? store_size() : maxnum};
@ -260,7 +259,7 @@ Query::Private::run(const std::string& expr,
}
Option<QueryResults>
Query::run(const std::string& expr, std::optional<Message::Field::Id> sortfield_id,
Query::run(const std::string& expr, std::optional<Field::Id> sortfield_id,
QueryFlags qflags, size_t maxnum) const
try {
// some flags are for internal use only.

10
lib/mu-query.hh
View File

@ -27,7 +27,7 @@
#include <mu-store.hh>
#include <mu-query-results.hh>
#include <utils/mu-utils.hh>
#include <mu-message.hh>
#include <message/mu-message.hh>
namespace Mu {
@ -44,10 +44,10 @@ public:
* @return the query-results, or Nothing in case of error.
*/
Option<QueryResults> run(const std::string& expr = "",
std::optional<Message::Field::Id> sortfield_id = {},
QueryFlags flags = QueryFlags::None,
size_t maxnum = 0) const;
Option<QueryResults> run(const std::string& expr = "",
std::optional<Field::Id> sortfield_id = {},
QueryFlags flags = QueryFlags::None,
size_t maxnum = 0) const;
/**
* run a Xapian query to count the number of matches; for the syntax, please

24
lib/mu-server.cc
View File

@ -19,8 +19,7 @@
#include "config.h"
#include "mu-message-flags.hh"
#include "mu-message-fields.hh"
#include "mu-message.hh"
#include "mu-msg.hh"
#include "mu-server.hh"
@ -49,7 +48,6 @@
#include "utils/mu-readline.hh"
using namespace Mu;
using namespace Mu::Message;
using namespace Command;
/// @brief object to manage the server-context for all commands.
@ -127,7 +125,7 @@ private:
Sexp::List perform_move(Store::Id docid,
MuMsg* msg,
const std::string& maildirarg,
MessageFlags flags,
Flags flags,
bool new_name,
bool no_view);
@ -523,7 +521,7 @@ Server::Private::contacts_handler(const Parameters& params)
auto rank{0};
Sexp::List contacts;
store().contacts_cache().for_each([&](const MessageContact& ci) {
store().contacts_cache().for_each([&](const Contact& ci) {
rank++;
/* since the last time we got some contacts */
@ -560,7 +558,7 @@ docids_for_msgid(const Store& store, const std::string& msgid, size_t max = 100)
throw Error(Error::Code::InvalidArgument, "invalid message-id '%s'", msgid.c_str());
}
const auto xprefix{message_field(Field::Id::MessageId).shortcut};
const auto xprefix{field_from_id(Field::Id::MessageId).shortcut};
/*XXX this is a bit dodgy */
auto tmp{g_ascii_strdown(msgid.c_str(), -1)};
auto expr{g_strdup_printf("%c:%s", xprefix, tmp)};
@ -674,7 +672,7 @@ Server::Private::find_handler(const Parameters& params)
const auto include_related{get_bool_or(params, ":include-related", false)};
auto sort_field = message_field_id(sortfieldstr);
auto sort_field = field_from_name(sortfieldstr);
if (!sort_field && sortfieldstr.empty())
throw Error{Error::Code::InvalidArgument, "invalid sort field %s",
sortfieldstr.c_str()};
@ -692,7 +690,7 @@ Server::Private::find_handler(const Parameters& params)
qflags |= QueryFlags::Threading;
std::lock_guard l{store_.lock()};
auto qres{store_.run_query(q, sort_field, qflags, maxnum)};
auto qres{store_.run_query(q, sort_field->id, qflags, maxnum)};
if (!qres)
throw Error(Error::Code::Query, "failed to run query");
@ -816,7 +814,7 @@ Sexp::List
Server::Private::perform_move(Store::Id docid,
MuMsg* msg,
const std::string& maildirarg,
MessageFlags flags,
Flags flags,
bool new_name,
bool no_view)
{
@ -853,15 +851,15 @@ Server::Private::perform_move(Store::Id docid,
}
static MessageFlags
static Flags
calculate_message_flags(MuMsg* msg, std::optional<std::string> flagopt)
{
const auto flags = std::invoke([&]()->std::optional<MessageFlags>{
const auto flags = std::invoke([&]()->std::optional<Flags>{
auto msgflags{mu_msg_get_flags(msg)};
if (!flagopt)
return mu_msg_get_flags(msg);
else
return message_flags_from_expr(*flagopt, msgflags);
return flags_from_expr(*flagopt, msgflags);
});
if (!flags)
@ -1043,7 +1041,7 @@ Server::Private::maybe_mark_as_read(MuMsg* msg, Store::Id docid, bool rename)
throw Error{Error::Code::Store, "missing message"};
const auto oldflags{mu_msg_get_flags(msg)};
const auto newflags{message_flags_from_delta_expr("+S-u-N", oldflags)};
const auto newflags{flags_from_delta_expr("+S-u-N", oldflags)};
if (!newflags || oldflags == *newflags)
return false; // nothing to do.

66
lib/mu-store.cc
View File

@ -35,8 +35,6 @@
#include <vector>
#include <xapian.h>
#include "mu-message-flags.hh"
#include "mu-message.hh"
#include "mu-msg.hh"
#include "mu-store.hh"
#include "mu-query.hh"
@ -48,7 +46,6 @@
#include "utils/mu-xapian-utils.hh"
using namespace Mu;
using namespace Mu::Message;
static_assert(std::is_same<Store::Id, Xapian::docid>::value, "wrong type for Store::Id");
@ -213,7 +210,7 @@ struct Store::Private {
void add_synonyms()
{
for (auto&& info: AllMessageFlagInfos) {
constexpr auto field{message_field(Field::Id::Flags)};
constexpr auto field{field_from_id(Field::Id::Flags)};
const auto s1{field.xapian_term(info.name)};
const auto s2{field.xapian_term(info.shortcut)};
writable_db().clear_synonyms(s1);
@ -222,7 +219,7 @@ struct Store::Private {
}
for (auto&& prio : AllMessagePriorities) {
constexpr auto field{message_field(Field::Id::Priority)};
constexpr auto field{field_from_id(Field::Id::Priority)};
const auto s1{field.xapian_term(to_string(prio))};
const auto s2{field.xapian_term(to_char(prio))};
writable_db().clear_synonyms(s1);
@ -310,7 +307,7 @@ hash_str(char* buf, size_t buf_size, const char* data)
static std::string
get_uid_term(const char* path)
{
return message_field(Field::Id::Uid).xapian_term(
return field_from_id(Field::Id::Uid).xapian_term(
format("016%" PRIx64, get_hash64(path)));
}
@ -588,7 +585,7 @@ Store::for_each_message_path(Store::ForEachMessageFunc msg_func) const
enq.set_cutoff(0, 0);
Xapian::MSet matches(enq.get_mset(0, priv_->db().get_doccount()));
constexpr auto path_no{message_field(Field::Id::Path).value_no()};
constexpr auto path_no{field_from_id(Field::Id::Path).value_no()};
for (auto&& it = matches.begin(); it != matches.end(); ++it, ++n)
if (!msg_func(*it, it.get_document().get_value(path_no)))
break;
@ -605,7 +602,7 @@ Store::commit()
}
std::size_t
Store::for_each_term(Message::Field::Id field_id, Store::ForEachTermFunc func) const
Store::for_each_term(Field::Id field_id, Store::ForEachTermFunc func) const
{
size_t n{};
@ -615,7 +612,7 @@ Store::for_each_term(Message::Field::Id field_id, Store::ForEachTermFunc func) c
* the message parser which already has the lock
*/
std::vector<std::string> terms;
const auto prefix{message_field(field_id).xapian_term()};
const auto prefix{field_from_id(field_id).xapian_term()};
for (auto it = priv_->db().allterms_begin(prefix);
it != priv_->db().allterms_end(prefix); ++it) {
if (!func(*it))
@ -666,7 +663,7 @@ Store::parse_query(const std::string& expr, bool xapian) const
static void
add_terms_values_date(Xapian::Document& doc, MuMsg* msg)
{
constexpr auto value_no{message_field(Field::Id::Date).value_no()};
constexpr auto value_no{field_from_id(Field::Id::Date).value_no()};
const auto dstr = Mu::date_to_time_t_string(
static_cast<time_t>(mu_msg_get_field_numeric(msg, Field::Id::Date)));
@ -676,7 +673,7 @@ add_terms_values_date(Xapian::Document& doc, MuMsg* msg)
static void
add_terms_values_size(Xapian::Document& doc, MuMsg* msg)
{
constexpr auto value_no{message_field(Field::Id::Size).value_no()};
constexpr auto value_no{field_from_id(Field::Id::Size).value_no()};
const auto szstr = Mu::size_to_string(mu_msg_get_field_numeric(
msg, Field::Id::Size));
doc.add_value(value_no, szstr);
@ -701,15 +698,15 @@ add_terms_values_number(Xapian::Document& doc, MuMsg* msg, const Field& field)
}
if (field.id == Field::Id::Flags) {
g_return_if_fail(num < static_cast<int64_t>(MessageFlags::_final_));
const auto msgflag{static_cast<MessageFlags>(num)};
message_flag_infos_for_each([&](auto&& info) {
g_return_if_fail(num < static_cast<int64_t>(Flags::_final_));
const auto msgflag{static_cast<Flags>(num)};
flag_infos_for_each([&](auto&& info) {
if (any_of(info.flag & msgflag))
add_term(doc, field.xapian_term(info.shortcut_lower()));
});
} else if (field.id == Field::Id::Priority)
add_term(doc,
field.xapian_term(to_char(static_cast<MessagePriority>(num))));
field.xapian_term(to_char(static_cast<Priority>(num))));
}
/* for string and string-list */
@ -787,7 +784,7 @@ maybe_index_text_part(Xapian::Document& doc, MuMsg* msg, MuMsgPart* part)
const auto str = Mu::utf8_flatten(txt);
g_free(txt);
static const auto pfx{message_field(Field::Id::EmbeddedText).xapian_term()};
static const auto pfx{field_from_id(Field::Id::EmbeddedText).xapian_term()};
termgen.index_text(str, 1, pfx);
}
@ -802,13 +799,13 @@ each_part(MuMsg* msg, MuMsgPart* part, DocHolder* doc_holder)
/* save the mime type of any part */
if (part->type)
add_term(doc, message_field(Field::Id::Mime)
add_term(doc, field_from_id(Field::Id::Mime)
.xapian_term(format("%s/%s", part->type, part->subtype)));
if (char *fname = mu_msg_part_get_filename(part, FALSE); fname) {
const auto flat{Mu::utf8_flatten(fname)};
g_free(fname);
add_term(doc, message_field(Field::Id::File).xapian_term(flat));
add_term(doc, field_from_id(Field::Id::File).xapian_term(flat));
}
maybe_index_text_part(doc, msg, part);
@ -828,7 +825,7 @@ add_terms_values_attach(Xapian::Document& doc, MuMsg* msg)
static void
add_terms_values_body(Xapian::Document& doc, MuMsg* msg, const Field& field)
{
if (any_of(mu_msg_get_flags(msg) & MessageFlags::Encrypted))
if (any_of(mu_msg_get_flags(msg) & Flags::Encrypted))
return; /* ignore encrypted bodies */
Xapian::TermGenerator termgen;
@ -866,29 +863,34 @@ add_contacts_terms_values(Xapian::Document& doc, MuMsg *msg,
Xapian::TermGenerator termgen;
termgen.set_document(doc);
for (auto&& contact: mu_msg_get_contacts(msg)) {
auto contacts{mu_msg_get_contacts(msg)};
for (auto&& contact: contacts) {
// e.g. Reply-To doesn't have a field connected.
const auto field_opt{contact.field()};
const auto field_opt{contact.field_id};
if (!field_opt)
goto next;
continue;
doc.add_value(field_opt->value_no(), contact.display_name());
add_term(doc, field_opt->xapian_term(contact.email));
const auto field{field_from_id(*field_opt)};
doc.add_value(field.value_no(), contact.display_name());
add_term(doc, field.xapian_term(contact.email));
if (!contact.name.empty())
termgen.index_text(utf8_flatten(contact.name),
1, field_opt->xapian_term());
1, field.xapian_term());
// index name / domain separately, too.
if (const auto at = contact.email.find('@'); at != std::string::npos) {
add_term(doc, field_opt->xapian_term(contact.email.substr(0, at)));
add_term(doc, field_opt->xapian_term(contact.email.substr(at)));
add_term(doc, field.xapian_term(contact.email.substr(0, at)));
add_term(doc, field.xapian_term(contact.email.substr(at)));
}
next:
contacts_cache.add(std::move(contact));
}
contacts_cache.add(std::move(contacts));
}
Xapian::Document
@ -897,9 +899,9 @@ Store::Private::new_doc_from_message(MuMsg* msg)
Xapian::Document doc;
add_contacts_terms_values(doc, msg, this->contacts_cache_);
message_field_for_each([&](auto&& field) {
field_for_each([&](auto&& field) {
if (!field.is_full_text() && !field.is_searchable() && !field.is_value())
if (!field.is_searchable() && !field.is_value())
return;
if (field.is_contact())
@ -939,7 +941,7 @@ static void
update_threading_info(MuMsg* msg, Xapian::Document& doc)
{
const GSList* refs;
const auto field{message_field(Field::Id::ThreadId)};
const auto field{field_from_id(Field::Id::ThreadId)};
// refs contains a list of parent messages, with the oldest
// one first until the last one, which is the direct parent of

6
lib/mu-store.hh
View File

@ -34,7 +34,7 @@
#include <index/mu-indexer.hh>
#include <mu-query-results.hh>
#include <utils/mu-utils.hh>
#include <mu-message.hh>
#include <message/mu-message.hh>
namespace Mu {
@ -156,7 +156,7 @@ public:
*/
std::mutex& lock() const;
Option<QueryResults> run_query(const std::string& expr = "",
std::optional<Message::Field::Id> sortfield_id = {},
std::optional<Field::Id> sortfield_id = {},
QueryFlags flags = QueryFlags::None,
size_t maxnum = 0) const;
@ -287,7 +287,7 @@ public:
*
* @return the number of times func was invoked
*/
size_t for_each_term(Message::Field::Id id, ForEachTermFunc func) const;
size_t for_each_term(Field::Id id, ForEachTermFunc func) const;
/**

45
lib/tests/meson.build
View File

@ -17,47 +17,6 @@
#
# tests
#
test('test-message-contact',
executable('test-message-contact',
'../mu-message-contact.cc',
install: false,
cpp_args: ['-DBUILD_TESTS'],
dependencies: [glib_dep, gmime_dep, lib_mu_dep,
lib_test_mu_common_dep]))
test('test-message-document',
executable('test-message-document',
'../mu-message-document.cc',
install: false,
cpp_args: ['-DBUILD_TESTS'],
dependencies: [glib_dep, gmime_dep, lib_mu_dep,
lib_test_mu_common_dep]))
test('test-message-fields',
executable('test-message-fields',
'../mu-message-fields.cc',
install: false,
cpp_args: ['-DBUILD_TESTS'],
dependencies: [glib_dep, gmime_dep, lib_mu_dep,
lib_test_mu_common_dep]))
test('test-message-flags',
executable('test-message-flags',
'../mu-message-flags.cc',
install: false,
cpp_args: ['-DBUILD_TESTS'],
dependencies: [glib_dep, gmime_dep, lib_mu_dep,
lib_test_mu_common_dep]))
test('test-message-priority',
executable('test-message-priority',
'../mu-message-priority.cc',
install: false,
cpp_args: ['-DBUILD_TESTS'],
dependencies: [glib_dep, gmime_dep, lib_mu_dep,
lib_test_mu_common_dep]))
test('test-maildir',
executable('test-maildir',
'test-mu-maildir.cc',
@ -77,7 +36,7 @@ test('test-query',
executable('test-query',
'test-query.cc',
install: false,
dependencies: [glib_dep, lib_mu_dep, lib_test_mu_common_dep]))
dependencies: [glib_dep, gmime_dep, lib_mu_dep, lib_test_mu_common_dep]))
test('test-tokenizer',
executable('test-tokenizer',
@ -101,4 +60,4 @@ test('test-parser',
executable('test-parser',
'test-parser.cc',
install: false,
dependencies: [glib_dep, lib_mu_dep, lib_test_mu_common_dep]))
dependencies: [glib_dep, gmime_dep, lib_mu_dep, lib_test_mu_common_dep]))

274
lib/tests/test-mu-maildir.cc
View File

@ -174,24 +174,24 @@ test_mu_maildir_flags_from_path(void)
int i;
struct {
const char* path;
MessageFlags flags;
Flags flags;
} paths[] = {
{"/home/foo/Maildir/test/cur/123456:2,FSR",
(MessageFlags::Replied | MessageFlags::Seen | MessageFlags::Flagged)},
{"/home/foo/Maildir/test/new/123456", MessageFlags::New},
(Flags::Replied | Flags::Seen | Flags::Flagged)},
{"/home/foo/Maildir/test/new/123456", Flags::New},
{/* NOTE: when in new/, the :2,.. stuff is ignored */
"/home/foo/Maildir/test/new/123456:2,FR",
MessageFlags::New},
Flags::New},
{"/home/foo/Maildir/test/cur/123456:2,DTP",
(MessageFlags::Draft | MessageFlags::Trashed | MessageFlags::Passed)},
{"/home/foo/Maildir/test/cur/123456:2,S", MessageFlags::Seen}};
(Flags::Draft | Flags::Trashed | Flags::Passed)},
{"/home/foo/Maildir/test/cur/123456:2,S", Flags::Seen}};
for (i = 0; i != G_N_ELEMENTS(paths); ++i) {
auto res{mu_maildir_flags_from_path(paths[i].path)};
g_assert_true(!!res);
if (g_test_verbose())
g_print("%s -> <%s>\n", paths[i].path,
message_flags_to_string(res.value()).c_str());
flags_to_string(res.value()).c_str());
g_assert_true(res.value() == paths[i].flags);
}
}
@ -214,7 +214,7 @@ test_determine_target_ok(void)
std::string old_path;
std::string root_maildir;
std::string target_maildir;
MessageFlags new_flags;
Flags new_flags;
bool new_name;
std::string expected;
};
@ -223,7 +223,7 @@ test_determine_target_ok(void)
"/home/foo/Maildir/test/cur/123456:2,FR",
"/home/foo/Maildir",
{},
MessageFlags::Seen | MessageFlags::Passed,
Flags::Seen | Flags::Passed,
false,
"/home/foo/Maildir/test/cur/123456:2,PS"
},
@ -232,7 +232,7 @@ test_determine_target_ok(void)
"/home/foo/Maildir/test/cur/123456:2,FR",
"/home/foo/Maildir",
{},
MessageFlags::New,
Flags::New,
false,
"/home/foo/Maildir/test/new/123456"
},
@ -241,7 +241,7 @@ test_determine_target_ok(void)
"/home/foo/Maildir/test/cur/123456",
"/home/foo/Maildir",
{},
MessageFlags::Seen | MessageFlags::Flagged,
Flags::Seen | Flags::Flagged,
false,
"/home/foo/Maildir/test/cur/123456:2,FS"
},
@ -250,7 +250,7 @@ test_determine_target_ok(void)
"/home/foo/Maildir/test/cur/123456:2,FR",
"/home/foo/Maildir",
"/test2",
MessageFlags::Flagged | MessageFlags::Replied,
Flags::Flagged | Flags::Replied,
false,
"/home/foo/Maildir/test2/cur/123456:2,FR"
},
@ -258,7 +258,7 @@ test_determine_target_ok(void)
"/home/foo/Maildir/test/new/123456",
"/home/foo/Maildir",
{},
MessageFlags::None,
Flags::None,
false,
"/home/foo/Maildir/test/cur/123456:2,"
},
@ -290,157 +290,157 @@ test_determine_target_ok(void)
// static void
// test_mu_maildir_determine_target(void)
// {
// int i;
// int i;
// struct {
// std::string oldpath;
// MessageFlags flags;
// std::string newpath;
// } paths[] = {{"/home/foo/Maildir/test/cur/123456:2,FR",
// MessageFlags::Replied,
// "/home/foo/Maildir/test/cur/123456:2,R"},
// {"/home/foo/Maildir/test/cur/123456:2,FR",
// MessageFlags::New,
// "/home/foo/Maildir/test/new/123456"},
// {"/home/foo/Maildir/test/new/123456:2,FR",
// (MessageFlags::Seen | MessageFlags::Replied),
// "/home/foo/Maildir/test/cur/123456:2,RS"},
// {"/home/foo/Maildir/test/new/1313038887_0.697:2,",
// (MessageFlags::Seen | MessageFlags::Flagged | MessageFlags::Passed),
// "/home/foo/Maildir/test/cur/1313038887_0.697:2,FPS"},
// {"/home/djcb/Maildir/trash/new/1312920597.2206_16.cthulhu",
// MessageFlags::Seen,
// "/home/djcb/Maildir/trash/cur/1312920597.2206_16.cthulhu:2,S"}};
// struct {
// std::string oldpath;
// Flags flags;
// std::string newpath;
// } paths[] = {{"/home/foo/Maildir/test/cur/123456:2,FR",
// Flags::Replied,
// "/home/foo/Maildir/test/cur/123456:2,R"},
// {"/home/foo/Maildir/test/cur/123456:2,FR",
// Flags::New,
// "/home/foo/Maildir/test/new/123456"},
// {"/home/foo/Maildir/test/new/123456:2,FR",
// (Flags::Seen | Flags::Replied),
// "/home/foo/Maildir/test/cur/123456:2,RS"},
// {"/home/foo/Maildir/test/new/1313038887_0.697:2,",
// (Flags::Seen | Flags::Flagged | Flags::Passed),
// "/home/foo/Maildir/test/cur/1313038887_0.697:2,FPS"},
// {"/home/djcb/Maildir/trash/new/1312920597.2206_16.cthulhu",
// Flags::Seen,
// "/home/djcb/Maildir/trash/cur/1312920597.2206_16.cthulhu:2,S"}};
// for (i = 0; i != G_N_ELEMENTS(paths); ++i) {
// const auto res{mu_maildir_determine_target(paths[i].oldpath,
// "/home/foo/Maildir",
// {},
// paths[i].flags, false)};
// g_assert_true(res && res.value() == paths[i].newpath);
// char *newbase = g_path_get_basename(newpath->c_str());
// assert_matches_regexp(newbase,
// "\\d+\\."
// "[[:xdigit:]]{16}\\."
// "[[:alnum:]][[:alnum:]-]+(:2,.*)?");
// g_free(newbase);
// }
// for (i = 0; i != G_N_ELEMENTS(paths); ++i) {
// const auto res{mu_maildir_determine_target(paths[i].oldpath,
// "/home/foo/Maildir",
// {},
// paths[i].flags, false)};
// g_assert_true(res && res.value() == paths[i].newpath);
// char *newbase = g_path_get_basename(newpath->c_str());
// assert_matches_regexp(newbase,
// "\\d+\\."
// "[[:xdigit:]]{16}\\."
// "[[:alnum:]][[:alnum:]-]+(:2,.*)?");
// g_free(newbase);
// }
// }
// static void
// test_mu_maildir_get_new_path_01(void)
// {
// struct {
// std::string oldpath;
// MessageFlags flags;
// std::string newpath;
// } paths[] = {{"/home/foo/Maildir/test/cur/123456:2,FR",
// MessageFlags::Replied,
// "/home/foo/Maildir/test/cur/123456:2,R"},
// {"/home/foo/Maildir/test/cur/123456:2,FR",
// MessageFlags::New,
// "/home/foo/Maildir/test/new/123456"},
// {"/home/foo/Maildir/test/new/123456:2,FR",
// (MessageFlags::Seen | MessageFlags::Replied),
// "/home/foo/Maildir/test/cur/123456:2,RS"},
// {"/home/foo/Maildir/test/new/1313038887_0.697:2,",
// (MessageFlags::Seen | MessageFlags::Flagged | MessageFlags::Passed),
// "/home/foo/Maildir/test/cur/1313038887_0.697:2,FPS"},
// {"/home/djcb/Maildir/trash/new/1312920597.2206_16.cthulhu",
// MessageFlags::Seen,
// "/home/djcb/Maildir/trash/cur/1312920597.2206_16.cthulhu:2,S"}};
// struct {
// std::string oldpath;
// Flags flags;
// std::string newpath;
// } paths[] = {{"/home/foo/Maildir/test/cur/123456:2,FR",
// Flags::Replied,
// "/home/foo/Maildir/test/cur/123456:2,R"},
// {"/home/foo/Maildir/test/cur/123456:2,FR",
// Flags::New,
// "/home/foo/Maildir/test/new/123456"},
// {"/home/foo/Maildir/test/new/123456:2,FR",
// (Flags::Seen | Flags::Replied),
// "/home/foo/Maildir/test/cur/123456:2,RS"},
// {"/home/foo/Maildir/test/new/1313038887_0.697:2,",
// (Flags::Seen | Flags::Flagged | Flags::Passed),
// "/home/foo/Maildir/test/cur/1313038887_0.697:2,FPS"},
// {"/home/djcb/Maildir/trash/new/1312920597.2206_16.cthulhu",
// Flags::Seen,
// "/home/djcb/Maildir/trash/cur/1312920597.2206_16.cthulhu:2,S"}};
// for (int i = 0; i != G_N_ELEMENTS(paths); ++i) {
// const auto newpath{mu_maildir_determine_target(
// paths[i].oldpath,
// "/home/foo/maildir",
// {}, paths[i].flags, false)};
// g_assert_true(newpath.has_value());
// g_assert_true(*newpath == paths[i].newpath);
// }
// for (int i = 0; i != G_N_ELEMENTS(paths); ++i) {
// const auto newpath{mu_maildir_determine_target(
// paths[i].oldpath,
// "/home/foo/maildir",
// {}, paths[i].flags, false)};
// g_assert_true(newpath.has_value());
// g_assert_true(*newpath == paths[i].newpath);
// }
// }
// static void
// test_mu_maildir_get_new_path_02(void)
// {
// struct {
// std::string oldpath;
// MessageFlags flags;
// std::string targetdir;
// std::string newpath;
// } paths[] = {{"/home/foo/Maildir/test/cur/123456:2,FR",
// MessageFlags::Replied,
// "/home/foo/Maildir/blabla",
// "/home/foo/Maildir/blabla/cur/123456:2,R"},
// {"/home/foo/Maildir/test/cur/123456:2,FR",
// MessageFlags::New,
// "/home/bar/Maildir/coffee",
// "/home/bar/Maildir/coffee/new/123456"},
// {"/home/foo/Maildir/test/new/123456",
// (MessageFlags::Seen | MessageFlags::Replied),
// "/home/cuux/Maildir/tea",
// "/home/cuux/Maildir/tea/cur/123456:2,RS"},
// {"/home/foo/Maildir/test/new/1313038887_0.697:2,",
// (MessageFlags::Seen | MessageFlags::Flagged | MessageFlags::Passed),
// "/home/boy/Maildir/stuff",
// "/home/boy/Maildir/stuff/cur/1313038887_0.697:2,FPS"}};
// struct {
// std::string oldpath;
// Flags flags;
// std::string targetdir;
// std::string newpath;
// } paths[] = {{"/home/foo/Maildir/test/cur/123456:2,FR",
// Flags::Replied,
// "/home/foo/Maildir/blabla",
// "/home/foo/Maildir/blabla/cur/123456:2,R"},
// {"/home/foo/Maildir/test/cur/123456:2,FR",
// Flags::New,
// "/home/bar/Maildir/coffee",
// "/home/bar/Maildir/coffee/new/123456"},
// {"/home/foo/Maildir/test/new/123456",
// (Flags::Seen | Flags::Replied),
// "/home/cuux/Maildir/tea",
// "/home/cuux/Maildir/tea/cur/123456:2,RS"},
// {"/home/foo/Maildir/test/new/1313038887_0.697:2,",
// (Flags::Seen | Flags::Flagged | Flags::Passed),
// "/home/boy/Maildir/stuff",
// "/home/boy/Maildir/stuff/cur/1313038887_0.697:2,FPS"}};
// for (int i = 0; i != G_N_ELEMENTS(paths); ++i) {
// auto newpath{mu_maildir_determine_target(paths[i].oldpath,
// paths[i].targetdir,
// paths[i].flags,
// false)};
// g_assert_true(newpath.has_value());
// g_assert_true(*newpath == paths[i].newpath);
// }
// for (int i = 0; i != G_N_ELEMENTS(paths); ++i) {
// auto newpath{mu_maildir_determine_target(paths[i].oldpath,
// paths[i].targetdir,
// paths[i].flags,
// false)};
// g_assert_true(newpath.has_value());
// g_assert_true(*newpath == paths[i].newpath);
// }
// }
// static void
// test_mu_maildir_get_new_path_custom(void)
// {
// struct {
// std::string oldpath;
// MessageFlags flags;
// std::string targetdir;
// std::string newpath;
// } paths[] = {{"/home/foo/Maildir/test/cur/123456:2,FR",
// MessageFlags::Replied,
// "/home/foo/Maildir/blabla",
// "/home/foo/Maildir/blabla/cur/123456:2,R"},
// {"/home/foo/Maildir/test/cur/123456:2,hFeRllo123",
// MessageFlags::Flagged,
// "/home/foo/Maildir/blabla",
// "/home/foo/Maildir/blabla/cur/123456:2,Fhello123"},
// {"/home/foo/Maildir/test/cur/123456:2,abc",
// MessageFlags::Passed,
// "/home/foo/Maildir/blabla",
// "/home/foo/Maildir/blabla/cur/123456:2,Pabc"}};
// struct {
// std::string oldpath;
// Flags flags;
// std::string targetdir;
// std::string newpath;
// } paths[] = {{"/home/foo/Maildir/test/cur/123456:2,FR",
// Flags::Replied,
// "/home/foo/Maildir/blabla",
// "/home/foo/Maildir/blabla/cur/123456:2,R"},
// {"/home/foo/Maildir/test/cur/123456:2,hFeRllo123",
// Flags::Flagged,
// "/home/foo/Maildir/blabla",
// "/home/foo/Maildir/blabla/cur/123456:2,Fhello123"},
// {"/home/foo/Maildir/test/cur/123456:2,abc",
// Flags::Passed,
// "/home/foo/Maildir/blabla",
// "/home/foo/Maildir/blabla/cur/123456:2,Pabc"}};
// for (int i = 0; i != G_N_ELEMENTS(paths); ++i) {
// auto newpath{mu_maildir_get_new_path(paths[i].oldpath,
// paths[i].targetdir,
// paths[i].flags,
// FALSE)};
// g_assert_true(newpath);
// g_assert_true(*newpath == paths[i].newpath);
// }
// for (int i = 0; i != G_N_ELEMENTS(paths); ++i) {
// auto newpath{mu_maildir_get_new_path(paths[i].oldpath,
// paths[i].targetdir,
// paths[i].flags,
// FALSE)};
// g_assert_true(newpath);
// g_assert_true(*newpath == paths[i].newpath);
// }
// }
// static void
// test_mu_maildir_from_path(void)
// {
// unsigned u;
// unsigned u;
// struct {
// std::string path, exp;
// } cases[] = {{"/home/foo/Maildir/test/cur/123456:2,FR", "/home/foo/Maildir/test"},
// {"/home/foo/Maildir/lala/new/1313038887_0.697:2,", "/home/foo/Maildir/lala"}};
// struct {
// std::string path, exp;
// } cases[] = {{"/home/foo/Maildir/test/cur/123456:2,FR", "/home/foo/Maildir/test"},
// {"/home/foo/Maildir/lala/new/1313038887_0.697:2,", "/home/foo/Maildir/lala"}};
// for (u = 0; u != G_N_ELEMENTS(cases); ++u) {
// auto mdir{mu_maildir_from_path(cases[u].path)};
// g_assert_true(mdir.has_value());
// g_assert_true(*mdir == cases[u].exp);
// }
// for (u = 0; u != G_N_ELEMENTS(cases); ++u) {
// auto mdir{mu_maildir_from_path(cases[u].path)};
// g_assert_true(mdir.has_value());
// g_assert_true(*mdir == cases[u].exp);
// }
// }
int

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

@ -49,8 +49,8 @@ get_msg(const char* path)
if (!msg) {
g_printerr("failed to load %s: %s\n",
path,
err ? err->message : "something went wrong");
path,
err ? err->message : "something went wrong");
g_clear_error(&err);
g_assert(0);
}
@ -70,22 +70,22 @@ test_mu_msg_01(void)
g_assert_cmpstr(mu_msg_get_subject(msg), ==, "gcc include search order");
g_assert_cmpstr(mu_msg_get_from(msg), ==, "Mickey Mouse <anon@example.com>");
g_assert_cmpstr(mu_msg_get_msgid(msg),
==,
"3BE9E6535E3029448670913581E7A1A20D852173@"
"emss35m06.us.lmco.com");
==,
"3BE9E6535E3029448670913581E7A1A20D852173@"
"emss35m06.us.lmco.com");
g_assert_cmpstr(mu_msg_get_header(msg, "Mailing-List"),
==,
"contact gcc-help-help@gcc.gnu.org; run by ezmlm");
g_assert_true(mu_msg_get_prio(msg) == Mu::MessagePriority::Normal);
==,
"contact gcc-help-help@gcc.gnu.org; run by ezmlm");
g_assert_true(mu_msg_get_prio(msg) == Priority::Normal);
g_assert_cmpuint(mu_msg_get_date(msg), ==, 1217530645);
const auto contacts{mu_msg_get_contacts(msg)};
g_assert_cmpuint(contacts.size(), == , 2);
g_assert_true(contacts[0].name == "Mickey Mouse");
g_assert_true(contacts[0].email == "anon@example.com");
g_assert_true(contacts[1].name == "Donald Duck");
g_assert_true(contacts[1].email == "gcc-help@gcc.gnu.org");
mu_msg_unref(msg);
}
@ -101,10 +101,10 @@ test_mu_msg_02(void)
g_assert_cmpstr(mu_msg_get_from(msg), ==, "anon@example.com");
g_assert_cmpstr(mu_msg_get_msgid(msg), ==, "r6bpm5-6n6.ln1@news.ducksburg.com");
g_assert_cmpstr(mu_msg_get_header(msg, "Errors-To"),
==,
"help-gnu-emacs-bounces+xxxx.klub=gmail.com@gnu.org");
==,
"help-gnu-emacs-bounces+xxxx.klub=gmail.com@gnu.org");
g_assert_true(mu_msg_get_prio(msg) /* 'low' */
== Mu::MessagePriority::Low);
== Priority::Low);
g_assert_cmpuint(mu_msg_get_date(msg), ==, 1218051515);
const auto contacts{mu_msg_get_contacts(msg)};
@ -114,8 +114,8 @@ test_mu_msg_02(void)
g_assert_true(contacts[1].name.empty());
g_assert_true(contacts[1].email == "help-gnu-emacs@gnu.org");
g_print("flags: %s\n", Mu::message_flags_to_string(mu_msg_get_flags(msg)).c_str());
g_assert_true(mu_msg_get_flags(msg) == (MessageFlags::Seen|MessageFlags::MailingList));
g_print("flags: %s\n", Mu::flags_to_string(mu_msg_get_flags(msg)).c_str());
g_assert_true(mu_msg_get_flags(msg) == (Flags::Seen|Flags::MailingList));
mu_msg_unref(msg);
}
@ -131,11 +131,11 @@ test_mu_msg_03(void)
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_true(mu_msg_get_prio(msg) /* 'low' */
== Mu::MessagePriority::Normal);
== Priority::Normal);
g_assert_cmpuint(mu_msg_get_date(msg), ==, 0);
g_assert_cmpstr(mu_msg_get_body_text(msg, MU_MSG_OPTION_NONE),
==,
"\nLet's write some fünkÿ text\nusing umlauts.\n\nFoo.\n");
==,
"\nLet's write some fünkÿ text\nusing umlauts.\n\nFoo.\n");
params = mu_msg_get_body_text_content_type_parameters(msg, MU_MSG_OPTION_NONE);
g_assert_cmpuint(g_slist_length((GSList*)params), ==, 2);
@ -143,7 +143,7 @@ test_mu_msg_03(void)
g_assert_cmpstr((char*)params->data, ==, "charset");
params = g_slist_next(params);
g_assert_cmpstr((char*)params->data, ==, "UTF-8");
g_assert_true(mu_msg_get_flags(msg) == (MessageFlags::Unread));
g_assert_true(mu_msg_get_flags(msg) == (Flags::Unread));
mu_msg_unref(msg);
}
@ -157,13 +157,13 @@ test_mu_msg_04(void)
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_true(mu_msg_get_prio(msg) /* 'low' */
== Mu::MessagePriority::Normal);
== Priority::Normal);
g_assert_cmpuint(mu_msg_get_date(msg), ==, 0);
g_assert_true(mu_msg_get_flags(msg) ==
(MessageFlags::HasAttachment|MessageFlags::Unread));
(Flags::HasAttachment|Flags::Unread));
g_assert_true(mu_msg_get_flags(msg) ==
(MessageFlags::HasAttachment|MessageFlags::Unread));
(Flags::HasAttachment|Flags::Unread));
mu_msg_unref(msg);
}
@ -177,7 +177,7 @@ test_mu_msg_multimime(void)
g_assert_cmpstr(mu_msg_get_subject(msg), ==, "multimime");
g_assert_cmpstr(mu_msg_get_body_text(msg, MU_MSG_OPTION_NONE), ==, "abcdef");
g_assert_true(mu_msg_get_flags(msg) ==
(MessageFlags::HasAttachment|MessageFlags::Flagged|MessageFlags::Seen));
(Flags::HasAttachment|Flags::Flagged|Flags::Seen));
mu_msg_unref(msg);
}
@ -189,19 +189,19 @@ test_mu_msg_flags(void)
struct {
const char* path;
MessageFlags flags;
Flags flags;
} msgflags[] = {{MU_TESTMAILDIR4 "/multimime!2,FS",
(MessageFlags::Flagged | MessageFlags::Seen |
MessageFlags::HasAttachment)},
{MU_TESTMAILDIR4 "/special!2,Sabc",
(MessageFlags::Seen|MessageFlags::HasAttachment)}
(Flags::Flagged | Flags::Seen |
Flags::HasAttachment)},
{MU_TESTMAILDIR4 "/special!2,Sabc",
(Flags::Seen|Flags::HasAttachment)}
};
for (u = 0; u != G_N_ELEMENTS(msgflags); ++u) {
MuMsg* msg;
g_assert((msg = get_msg(msgflags[u].path)));
const auto flags{mu_msg_get_flags(msg)};
//g_print("flags: %s\n", Mu::message_flags_to_string(flags).c_str());
//g_print("flags: %s\n", Mu::flags_to_string(flags).c_str());
g_assert_true(flags == msgflags[u].flags);
mu_msg_unref(msg);
}
@ -217,7 +217,7 @@ test_mu_msg_umlaut(void)
g_assert_cmpstr(mu_msg_get_subject(msg), ==, "Motörhead");
g_assert_cmpstr(mu_msg_get_from(msg), ==, "Mü <testmu@testmu.xx>");
g_assert_true(mu_msg_get_prio(msg) /* 'low' */
== Mu::MessagePriority::Normal);
== Priority::Normal);
g_assert_cmpuint(mu_msg_get_date(msg), ==, 0);
mu_msg_unref(msg);
@ -284,17 +284,17 @@ test_mu_msg_references_many(void)
unsigned u;
const GSList *refs, *cur;
const char* expt_refs[] = {
"e9065dac-13c1-4103-9e31-6974ca232a89@t15g2000prt.googlegroups.com",
"87hbblwelr.fsf@sapphire.mobileactivedefense.com",
"pql248-4va.ln1@wilbur.25thandClement.com",
"ikns6r$li3$1@Iltempo.Update.UU.SE",
"8762s0jreh.fsf@sapphire.mobileactivedefense.com",
"ikqqp1$jv0$1@Iltempo.Update.UU.SE",
"87hbbjc5jt.fsf@sapphire.mobileactivedefense.com",
"ikr0na$lru$1@Iltempo.Update.UU.SE",
"tO8cp.1228$GE6.370@news.usenetserver.com",
"ikr6ks$nlf$1@Iltempo.Update.UU.SE",
"8ioh48-8mu.ln1@leafnode-msgid.gclare.org.uk"};
"e9065dac-13c1-4103-9e31-6974ca232a89@t15g2000prt.googlegroups.com",
"87hbblwelr.fsf@sapphire.mobileactivedefense.com",
"pql248-4va.ln1@wilbur.25thandClement.com",
"ikns6r$li3$1@Iltempo.Update.UU.SE",
"8762s0jreh.fsf@sapphire.mobileactivedefense.com",
"ikqqp1$jv0$1@Iltempo.Update.UU.SE",
"87hbbjc5jt.fsf@sapphire.mobileactivedefense.com",
"ikr0na$lru$1@Iltempo.Update.UU.SE",
"tO8cp.1228$GE6.370@news.usenetserver.com",
"ikr6ks$nlf$1@Iltempo.Update.UU.SE",
"8ioh48-8mu.ln1@leafnode-msgid.gclare.org.uk"};
msg = get_msg(MU_TESTMAILDIR2 "/bar/cur/181736.eml");
refs = mu_msg_get_references(msg);
@ -321,11 +321,11 @@ test_mu_msg_tags(void)
g_assert_cmpstr(mu_msg_get_to(msg), ==, "Julius Caesar <jc@example.com>");
g_assert_cmpstr(mu_msg_get_subject(msg),
==,
"Fere libenter homines id quod volunt credunt");
==,
"Fere libenter homines id quod volunt credunt");
g_assert_cmpstr(mu_msg_get_from(msg), ==, "John Milton <jm@example.com>");
g_assert_true(mu_msg_get_prio(msg) /* 'low' */
== Mu::MessagePriority::High);
== Priority::High);
g_assert_cmpuint(mu_msg_get_date(msg), ==, 1217530645);
tags = mu_msg_get_tags(msg);
@ -348,31 +348,31 @@ test_mu_msg_comp_unix_programmer(void)
msg = get_msg(MU_TESTMAILDIR4 "/181736.eml");
g_assert_cmpstr(mu_msg_get_to(msg), ==, NULL);
g_assert_cmpstr(mu_msg_get_subject(msg),
==,
"Re: Are writes \"atomic\" to readers of the file?");
==,
"Re: Are writes \"atomic\" to readers of the file?");
g_assert_cmpstr(mu_msg_get_from(msg), ==, "Jimbo Foobarcuux <jimbo@slp53.sl.home>");
g_assert_cmpstr(mu_msg_get_msgid(msg), ==, "oktdp.42997$Te.22361@news.usenetserver.com");
refs = mu_str_from_list(mu_msg_get_references(msg), ',');
g_assert_cmpstr(refs,
==,
"e9065dac-13c1-4103-9e31-6974ca232a89@t15g2000prt"
".googlegroups.com,"
"87hbblwelr.fsf@sapphire.mobileactivedefense.com,"
"pql248-4va.ln1@wilbur.25thandClement.com,"
"ikns6r$li3$1@Iltempo.Update.UU.SE,"
"8762s0jreh.fsf@sapphire.mobileactivedefense.com,"
"ikqqp1$jv0$1@Iltempo.Update.UU.SE,"
"87hbbjc5jt.fsf@sapphire.mobileactivedefense.com,"
"ikr0na$lru$1@Iltempo.Update.UU.SE,"
"tO8cp.1228$GE6.370@news.usenetserver.com,"
"ikr6ks$nlf$1@Iltempo.Update.UU.SE,"
"8ioh48-8mu.ln1@leafnode-msgid.gclare.org.uk");
==,
"e9065dac-13c1-4103-9e31-6974ca232a89@t15g2000prt"
".googlegroups.com,"
"87hbblwelr.fsf@sapphire.mobileactivedefense.com,"
"pql248-4va.ln1@wilbur.25thandClement.com,"
"ikns6r$li3$1@Iltempo.Update.UU.SE,"
"8762s0jreh.fsf@sapphire.mobileactivedefense.com,"
"ikqqp1$jv0$1@Iltempo.Update.UU.SE,"
"87hbbjc5jt.fsf@sapphire.mobileactivedefense.com,"
"ikr0na$lru$1@Iltempo.Update.UU.SE,"
"tO8cp.1228$GE6.370@news.usenetserver.com,"
"ikr6ks$nlf$1@Iltempo.Update.UU.SE,"
"8ioh48-8mu.ln1@leafnode-msgid.gclare.org.uk");
g_free(refs);
//"jimbo@slp53.sl.home (Jimbo Foobarcuux)";
g_assert_true(mu_msg_get_prio(msg) /* 'low' */
== Mu::MessagePriority::Normal);
== Priority::Normal);
g_assert_cmpuint(mu_msg_get_date(msg), ==, 1299603860);
mu_msg_unref(msg);
@ -381,9 +381,9 @@ test_mu_msg_comp_unix_programmer(void)
static void
test_mu_str_prio_01(void)
{
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");
g_assert_true(priority_name(Priority::Low) == "low");
g_assert_true(priority_name(Priority::Normal) == "normal");
g_assert_true(priority_name(Priority::High) == "high");
}
G_GNUC_UNUSED static gboolean
@ -400,9 +400,9 @@ test_mu_str_display_contact(void)
const char* word;
const char* disp;
} words[] = {{"\"Foo Bar\" <aap@noot.mies>", "Foo Bar"},
{"Foo Bar <aap@noot.mies>", "Foo Bar"},
{"<aap@noot.mies>", "aap@noot.mies"},
{"foo@bar.nl", "foo@bar.nl"}};
{"Foo Bar <aap@noot.mies>", "Foo Bar"},
{"<aap@noot.mies>", "aap@noot.mies"},
{"foo@bar.nl", "foo@bar.nl"}};
for (i = 0; i != G_N_ELEMENTS(words); ++i)
g_assert_cmpstr(mu_str_display_contact_s(words[i].word), ==, words[i].disp);

1
lib/tests/test-query.cc
View File

@ -32,7 +32,6 @@
#include "test-mu-common.hh"
using namespace Mu;
using namespace Mu::Message;
static void
test_query()

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

@ -21,6 +21,7 @@
#define MU_XAPIAN_UTILS_HH__
#include <xapian.h>
#include <glib.h>
namespace Mu {

2
mu/meson.build
View File

@ -35,7 +35,7 @@ mu = executable(
'mu-config.hh',
mu_help_strings_h
],
dependencies: [ glib_dep, lib_mu_dep, thread_dep, config_h_dep ],
dependencies: [ glib_dep, gmime_dep, lib_mu_dep, thread_dep, config_h_dep ],
cpp_args: ['-DMU_SCRIPTS_DIR="'+ join_paths(datadir, 'mu', 'scripts') + '"'],
install: true)

2
mu/mu-cmd-cfind.cc
View File

@ -274,7 +274,7 @@ struct ECData {
};
static void
each_contact(const Mu::MessageContact& ci, ECData& ecdata)
each_contact(const Mu::Contact& ci, ECData& ecdata)
{
if (ecdata.personal && ci.personal)
return;

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

@ -28,13 +28,14 @@
#include <stdlib.h>
#include <signal.h>
#include "message/mu-fields.hh"
#include "mu-msg.hh"
#include "mu-maildir.hh"
#include "mu-query-match-deciders.hh"
#include "mu-query.hh"
#include "mu-bookmarks.hh"
#include "mu-runtime.hh"
#include "mu-message.hh"
#include "message/mu-message.hh"
#include "utils/mu-util.h"
#include "utils/mu-str.h"
@ -43,7 +44,6 @@
#include "utils/mu-utils.hh"
using namespace Mu;
using namespace Mu::Message;
struct OutputInfo {
Xapian::docid docid{};
@ -74,8 +74,8 @@ static Option<QueryResults>
run_query(const Store& store, const std::string& expr, const MuConfig* opts,
GError** err)
{
const auto sortfield_id{message_field_id(opts->sortfield ? opts->sortfield : "")};
if (!sortfield_id && opts->sortfield) {
const auto sortfield{field_from_name(opts->sortfield ? opts->sortfield : "")};
if (!sortfield && opts->sortfield) {
g_set_error(err, MU_ERROR_DOMAIN, MU_ERROR_IN_PARAMETERS,
"invvalid sort field: '%s'\n", opts->sortfield);
return Nothing;
@ -91,7 +91,7 @@ run_query(const Store& store, const std::string& expr, const MuConfig* opts,
if (opts->threads)
qflags |= QueryFlags::Threading;
return store.run_query(expr, sortfield_id, qflags, opts->maxnum);
return store.run_query(expr, sortfield->id, qflags, opts->maxnum);
}
static gboolean
@ -233,7 +233,7 @@ ansi_color_maybe(Field::Id field_id, gboolean color)
case Field::Id::Date: ansi = MU_COLOR_MAGENTA; break;
default:
if (message_field(field_id).type != Field::Type::String)
if (field_from_id(field_id).type != Field::Type::String)
ansi = MU_COLOR_YELLOW;
else
ansi = MU_COLOR_RED;
@ -275,10 +275,10 @@ field_string_list(MuMsg* msg, Field::Id field_id)
/* ugly... for backward compat */
static const char*
flags_s(MessageFlags flags)
flags_s(Flags flags)
{
static char buf[64];
const auto flagstr{message_flags_to_string(flags)};
const auto flagstr{flags_to_string(flags)};
::strncpy(buf, flagstr.c_str(), sizeof(buf) - 1);
@ -290,7 +290,7 @@ display_field(MuMsg* msg, Field::Id field_id)
{
gint64 val;
switch (message_field(field_id).type) {
switch (field_from_id(field_id).type) {
case Field::Type::String: {
const gchar* str;
str = mu_msg_get_field_string(msg, field_id);
@ -299,11 +299,11 @@ display_field(MuMsg* msg, Field::Id field_id)
case Field::Type::Integer:
if (field_id == Field::Id::Priority) {
const auto val = static_cast<char>(mu_msg_get_field_numeric(msg, field_id));
const auto prio = message_priority_from_char(val);
return message_priority_name_c_str(prio);
const auto prio = priority_from_char(val);
return priority_name_c_str(prio);
} else if (field_id == Field::Id::Flags) {
val = mu_msg_get_field_numeric(msg, field_id);
return flags_s(static_cast<MessageFlags>(val));
return flags_s(static_cast<Flags>(val));
} else /* as string */
return mu_msg_get_field_string(msg, field_id);
@ -384,16 +384,15 @@ output_plain_fields(MuMsg* msg, const char* fields, gboolean color, gboolean thr
g_return_if_fail(fields);
for (myfields = fields, nonempty = 0; *myfields; ++myfields) {
const auto id_opt{message_field_id(*myfields)};
if (!id_opt || (!message_field(*id_opt).is_value() &&
!message_field(*id_opt).is_contact()))
const auto field_opt{field_from_shortcut(*myfields)};
if (!field_opt || (!field_opt->is_value() && !field_opt->is_contact()))
nonempty += printf("%c", *myfields);
else {
ansi_color_maybe(*id_opt, color);
nonempty += mu_util_fputs_encoded(display_field(msg, *id_opt).c_str(),
stdout);
ansi_reset_maybe(*id_opt, color);
ansi_color_maybe(field_opt->id, color);
nonempty += mu_util_fputs_encoded(
display_field(msg, field_opt->id).c_str(), stdout);
ansi_reset_maybe(field_opt->id, color);
}
}

46
mu/mu-cmd.cc
View File

@ -34,7 +34,7 @@
#include "mu-maildir.hh"
#include "mu-contacts-cache.hh"
#include "mu-runtime.hh"
#include "mu-message-flags.hh"
#include "message/mu-message.hh"
#include "utils/mu-util.h"
#include "utils/mu-str.h"
@ -49,7 +49,7 @@ static gboolean
view_msg_sexp(MuMsg* msg, const MuConfig* opts)
{
::fputs(msg_to_sexp(msg, 0, mu_config_get_msg_options(opts)).to_sexp_string().c_str(),
stdout);
stdout);
return TRUE;
}
@ -121,10 +121,10 @@ body_or_summary(MuMsg* msg, const MuConfig* opts)
color = !opts->nocolor;
body = mu_msg_get_body_text(msg, (MuMsgOptions)my_opts);
if (!body) {
if (any_of(mu_msg_get_flags(msg) & MessageFlags::Encrypted)) {
if (any_of(mu_msg_get_flags(msg) & Flags::Encrypted)) {
color_maybe(MU_COLOR_CYAN);
g_print("[No body found; "
"message has encrypted parts]\n");
"message has encrypted parts]\n");
} else {
color_maybe(MU_COLOR_MAGENTA);
g_print("[No body found]\n");
@ -308,7 +308,7 @@ foreach_msg_file(Mu::Store& store, const MuConfig* opts, ForeachMsgFunc foreach_
/* note: params[0] will be 'add' */
if (!opts->params[0] || !opts->params[1]) {
g_print("usage: mu %s <file> [<files>]\n",
opts->params[0] ? opts->params[0] : "<cmd>");
opts->params[0] ? opts->params[0] : "<cmd>");
mu_util_g_set_error(err, MU_ERROR_IN_PARAMETERS, "missing parameters");
return MU_ERROR_IN_PARAMETERS;
}
@ -327,8 +327,8 @@ foreach_msg_file(Mu::Store& store, const MuConfig* opts, ForeachMsgFunc foreach_
if (!foreach_func(store, path, err)) {
all_ok = FALSE;
g_printerr("error with %s: %s\n",
path,
(err && *err) ? (*err)->message : "something went wrong");
path,
(err && *err) ? (*err)->message : "something went wrong");
g_clear_error(err);
continue;
}
@ -336,9 +336,9 @@ foreach_msg_file(Mu::Store& store, const MuConfig* opts, ForeachMsgFunc foreach_
if (!all_ok) {
mu_util_g_set_error(err,
MU_ERROR_XAPIAN_STORE_FAILED,
"%s failed for some message(s)",
opts->params[0]);
MU_ERROR_XAPIAN_STORE_FAILED,
"%s failed for some message(s)",
opts->params[0]);
return MU_ERROR_XAPIAN_STORE_FAILED;
}
@ -399,14 +399,14 @@ each_sig(MuMsg* msg, MuMsgPart* part, VData* vdata)
if (vdata->oneline)
vdata->report = g_strdup_printf("%s%s%s",
vdata->report ? vdata->report : "",
vdata->report ? "; " : "",
report->report);
vdata->report ? vdata->report : "",
vdata->report ? "; " : "",
report->report);
else
vdata->report = g_strdup_printf("%s%s\t%s",
vdata->report ? vdata->report : "",
vdata->report ? "\n" : "",
report->report);
vdata->report ? vdata->report : "",
vdata->report ? "\n" : "",
report->report);
if (vdata->combined_status == MU_MSG_PART_SIG_STATUS_BAD ||
vdata->combined_status == MU_MSG_PART_SIG_STATUS_ERROR)
@ -536,16 +536,16 @@ cmd_init(const MuConfig* opts, GError** err)
/* not provided, nor could we find a good default */
if (!opts->maildir) {
mu_util_g_set_error(err,
MU_ERROR_IN_PARAMETERS,
"missing --maildir parameter and could "
"not determine default");
MU_ERROR_IN_PARAMETERS,
"missing --maildir parameter and could "
"not determine default");
return MU_ERROR_IN_PARAMETERS;
}
if (opts->max_msg_size < 0) {
mu_util_g_set_error(err,
MU_ERROR_IN_PARAMETERS,
"invalid value for max-message-size");
MU_ERROR_IN_PARAMETERS,
"invalid value for max-message-size");
return MU_ERROR_IN_PARAMETERS;
} else if (opts->batch_size < 0) {
mu_util_g_set_error(err, MU_ERROR_IN_PARAMETERS, "invalid value for batch-size");
@ -585,9 +585,9 @@ show_usage(void)
{
g_print("usage: mu command [options] [parameters]\n");
g_print("where command is one of index, find, cfind, view, mkdir, "
"extract, add, remove, script, verify or server\n");
"extract, add, remove, script, verify or server\n");
g_print("see the mu, mu-<command> or mu-easy manpages for "
"more information\n");
"more information\n");
}
typedef MuError (*readonly_store_func)(const Mu::Store&, const MuConfig*, GError** err);

2
mu/mu-config.hh
View File

@ -22,7 +22,7 @@
#include <glib.h>
#include <sys/types.h> /* for mode_t */
#include <mu-message.hh>
#include <message/mu-message.hh>
#include <mu-msg.hh>
#include <utils/mu-util.h>