+ * Copyright (c) 2010-2017 Isode Limited.

+#include <Swift/Controllers/Highlighting/Highlighter.h>

+ : ChatControllerBase(self, stanzaChannel, iqRouter, chatWindowFactory, contact, nickResolver, presenceOracle, avatarManager, useDelayForLatency, eventStream, eventController, timerFactory, entityCapsProvider, historyController, mucRegistry, highlightManager, chatMessageParser, autoAcceptMUCInviteDecider), userWantsReceipts_(userWantsReceipts), settings_(settings), clientBlockListManager_(clientBlockListManager) {

+ highlighter_->handleSystemNotifications(chatMessage, messageEvent);

+ highlighter_->handleSoundNotifications(chatMessage);

+ * Copyright (c) 2010-2017 Isode Limited.

+#include <Swift/Controllers/Highlighting/HighlightManager.h>

+#include <Swift/Controllers/Highlighting/Highlighter.h>

+ChatControllerBase::ChatControllerBase(const JID& self, StanzaChannel* stanzaChannel, IQRouter* iqRouter, ChatWindowFactory* chatWindowFactory, const JID &toJID, NickResolver* nickResolver, PresenceOracle* presenceOracle, AvatarManager* avatarManager, bool useDelayForLatency, UIEventStream* eventStream, EventController* eventController, TimerFactory* timerFactory, EntityCapsProvider* entityCapsProvider, HistoryController* historyController, MUCRegistry* mucRegistry, HighlightManager* highlightManager, std::shared_ptr<ChatMessageParser> chatMessageParser, AutoAcceptMUCInviteDecider* autoAcceptMUCInviteDecider) : selfJID_(self), stanzaChannel_(stanzaChannel), iqRouter_(iqRouter), chatWindowFactory_(chatWindowFactory), toJID_(toJID), labelsEnabled_(false), presenceOracle_(presenceOracle), avatarManager_(avatarManager), useDelayForLatency_(useDelayForLatency), eventController_(eventController), timerFactory_(timerFactory), entityCapsProvider_(entityCapsProvider), historyController_(historyController), mucRegistry_(mucRegistry), chatMessageParser_(chatMessageParser), autoAcceptMUCInviteDecider_(autoAcceptMUCInviteDecider), eventStream_(eventStream) {

+ highlighter_ = highlightManager->createHighlighter(nickResolver);

+ChatWindow::ChatMessage ChatControllerBase::buildChatWindowChatMessage(const std::string& message, const std::string& senderName, bool senderIsSelf) {

+ chatMessage = chatMessageParser_->parseMessageBody(message, senderName, senderIsSelf);

+ chatMessage = buildChatWindowChatMessage(body, senderHighlightNameFromMessage(from), senderIsSelf);

+ chatMessage = buildChatWindowChatMessage(body, senderHighlightNameFromMessage(from), senderIsSelf);

+ * Copyright (c) 2010-2017 Isode Limited.

+#include <Swift/Controllers/Highlighting/HighlightManager.h>

+ class AutoAcceptMUCInviteDecider;

+ class ChatMessageParser;

+ class ChatWindowFactory;

+ class EventController;

+ class IQRouter;

+ class NickResolver;

+ class StanzaChannel;

+ class UIEventStream;

+ ChatControllerBase(const JID& self, StanzaChannel* stanzaChannel, IQRouter* iqRouter, ChatWindowFactory* chatWindowFactory, const JID &toJID, NickResolver* nickResolver, PresenceOracle* presenceOracle, AvatarManager* avatarManager, bool useDelayForLatency, UIEventStream* eventStream, EventController* eventController, TimerFactory* timerFactory, EntityCapsProvider* entityCapsProvider, HistoryController* historyController, MUCRegistry* mucRegistry, HighlightManager* highlightManager, std::shared_ptr<ChatMessageParser> chatMessageParser, AutoAcceptMUCInviteDecider* autoAcceptMUCInviteDecider);

+ ChatWindow::ChatMessage buildChatWindowChatMessage(const std::string& message, const std::string& senderName, bool senderIsSelf);

+ * Copyright (c) 2013-2017 Isode Limited.

+#include <algorithm>

+#include <boost/regex.hpp>

+ ChatMessageParser::ChatMessageParser(const std::map<std::string, std::string>& emoticons, std::shared_ptr<HighlightConfiguration> highlightConfiguration, Mode mode) : emoticons_(emoticons), highlightConfiguration_(highlightConfiguration), mode_(mode) {

+ ChatWindow::ChatMessage ChatMessageParser::parseMessageBody(const std::string& body, const std::string& senderNickname, bool senderIsSelf) {

+

+ // Highlight keywords and own mentions.

+ parsedMessage = splitHighlight(parsedMessage);

+

+ // Highlight full message events like, specific sender, general

+ // incoming group message, or general incoming direct message.

+ parsedMessage = fullMessageHighlight(parsedMessage, senderNickname);

+ for (const auto& part : parsedMessage.getParts()) {

+

+ ChatWindow::ChatMessage ChatMessageParser::splitHighlight(const ChatWindow::ChatMessage& message) {

+ auto keywordToRegEx = [](const std::string& keyword, bool matchCaseSensitive) {

+ std::string escaped = Regex::escape(keyword);

+ boost::regex::flag_type flags = boost::regex::normal;

+ if (!matchCaseSensitive) {

+ flags |= boost::regex::icase;

+ return boost::regex("\\b" + escaped + "\\b", flags);

+ };

+

+ auto highlightKeywordInChatMessage = [&](const ChatWindow::ChatMessage& message, const std::string& keyword, bool matchCaseSensitive, const HighlightAction& action) {

+ ChatWindow::ChatMessage resultMessage;

+

+ for (const auto& part : message.getParts()) {

+ std::shared_ptr<ChatWindow::ChatTextMessagePart> textPart;

+ if ((textPart = std::dynamic_pointer_cast<ChatWindow::ChatTextMessagePart>(part))) {

+ try {

+ boost::match_results<std::string::const_iterator> match;

+ const std::string& text = textPart->text;

+ std::string::const_iterator start = text.begin();

+ while (regex_search(start, text.end(), match, keywordToRegEx(keyword, matchCaseSensitive))) {

+ std::string::const_iterator matchStart = match[0].first;

+ std::string::const_iterator matchEnd = match[0].second;

+ if (start != matchStart) {

+ /* If we're skipping over plain text since the previous emoticon, record it as plain text */

+ resultMessage.append(std::make_shared<ChatWindow::ChatTextMessagePart>(std::string(start, matchStart)));

+ std::shared_ptr<ChatWindow::ChatHighlightingMessagePart> highlightPart = std::make_shared<ChatWindow::ChatHighlightingMessagePart>();

+ highlightPart->text = match.str();

+ highlightPart->action = action;

+ resultMessage.append(highlightPart);

+ start = matchEnd;

+ if (start != text.end()) {

+ /* If there's plain text after the last emoticon, record it */

+ resultMessage.append(std::make_shared<ChatWindow::ChatTextMessagePart>(std::string(start, text.end())));

+ catch (std::runtime_error) {

+ /* Basically too expensive to compute the regex results and it gave up, so pass through as text */

+ resultMessage.append(part);

+ }

+ } else {

+ resultMessage.append(part);

+ return resultMessage;

+ };

+

+ ChatWindow::ChatMessage parsedMessage = message;

+

+ // detect mentions of own nickname

+ HighlightAction ownMentionKeywordAction = highlightConfiguration_->ownMentionAction;

+ ownMentionKeywordAction.setSoundFilePath(boost::optional<std::string>());

+ ownMentionKeywordAction.setSystemNotificationEnabled(false);

+ if (!getNick().empty() && !highlightConfiguration_->ownMentionAction.isEmpty()) {

+ auto nicknameHighlightedMessage = highlightKeywordInChatMessage(parsedMessage, nick_, false, ownMentionKeywordAction);

+ auto highlightedParts = nicknameHighlightedMessage.getParts();

+ auto ownNicknamePart = std::find_if(highlightedParts.begin(), highlightedParts.end(), [&](std::shared_ptr<ChatWindow::ChatMessagePart>& part){

+ auto highlightPart = std::dynamic_pointer_cast<ChatWindow::ChatHighlightingMessagePart>(part);

+ if (highlightPart && highlightPart->text == nick_) {

+ return true;

+ }

+ return false;

+ });

+ if (ownNicknamePart != highlightedParts.end()) {

+ parsedMessage.setHighlightActionOwnMention(highlightConfiguration_->ownMentionAction);

+ }

+ parsedMessage.setParts(nicknameHighlightedMessage.getParts());

+ }

+

+ // detect keywords

+ for (const auto& keywordHighlight : highlightConfiguration_->keywordHighlights) {

+ if (keywordHighlight.keyword.empty() || keywordHighlight.action.isEmpty()) {

+ continue;

+ }

+ auto newMessage = highlightKeywordInChatMessage(parsedMessage, keywordHighlight.keyword, keywordHighlight.matchCaseSensitive, keywordHighlight.action);

+ parsedMessage.setParts(newMessage.getParts());

+

+ ChatWindow::ChatMessage ChatMessageParser::fullMessageHighlight(const ChatWindow::ChatMessage& parsedMessage, const std::string& sender) {

+ auto fullHighlightedMessage = parsedMessage;

+

+ // contact highlighting

+ for (const auto& contactHighlight : highlightConfiguration_->contactHighlights) {

+ if (sender == contactHighlight.name) {

+ fullHighlightedMessage.setHighlightActionSender(contactHighlight.action);

+ break;

+ }

+ }

+

+ // general incoming messages

+ HighlightAction groupAction;

+ HighlightAction chatAction;

+

+ switch (mode_) {

+ case Mode::GroupChat:

+ groupAction.setSoundFilePath(highlightConfiguration_->playSoundOnIncomingGroupchatMessages ? boost::optional<std::string>("") : boost::optional<std::string>());

+ groupAction.setSystemNotificationEnabled(highlightConfiguration_->showNotificationOnIncomingGroupchatMessages);

+ fullHighlightedMessage.setHighlightActionGroupMessage(groupAction);

+ break;

+

+ case Mode::Chat:

+ chatAction.setSoundFilePath(highlightConfiguration_->playSoundOnIncomingDirectMessages ? boost::optional<std::string>("") : boost::optional<std::string>());

+ chatAction.setSystemNotificationEnabled(highlightConfiguration_->showNotificationOnIncomingDirectMessages);

+ fullHighlightedMessage.setHighlightActonDirectMessage(chatAction);

+ break;

+ }

+

+ return fullHighlightedMessage;

+ }

+ * Copyright (c) 2013-2017 Isode Limited.

+#include <memory>

+#include <Swift/Controllers/Highlighting/HighlightConfiguration.h>

+ /**

+ * @brief The ChatMessageParser class takes an emoticon map, a \ref HighlightConfiguration, and a boolean that indicates if the message context is in a MUC or not.

+ * The class handles parsing a message string and identifies emoticons, URLs, and various highlights.

+ */

+ enum class Mode { Chat, GroupChat };

+

+ public:

+ ChatMessageParser(const std::map<std::string, std::string>& emoticons, std::shared_ptr<HighlightConfiguration> highlightConfiguration, Mode mode = Mode::Chat);

+

+ void setNick(const std::string& nick) { nick_ = nick; }

+ std::string getNick() const { return nick_; }

+

+ ChatWindow::ChatMessage parseMessageBody(const std::string& body, const std::string& sender = "", bool senderIsSelf = false);

+

+ ChatWindow::ChatMessage splitHighlight(const ChatWindow::ChatMessage& parsedMessage);

+ ChatWindow::ChatMessage fullMessageHighlight(const ChatWindow::ChatMessage& parsedMessage, const std::string& sender);

+

+ private:

+ std::shared_ptr<HighlightConfiguration> highlightConfiguration_;

+ Mode mode_;

+ std::string nick_;

+ * Copyright (c) 2010-2017 Isode Limited.

+ std::shared_ptr<ChatMessageParser> chatMessageParser = std::make_shared<ChatMessageParser>(emoticons_, highlightManager_->getConfiguration(), ChatMessageParser::Mode::Chat); /* a message parser that knows this is a chat (not a room/MUC) */

+ std::shared_ptr<ChatMessageParser> chatMessageParser = std::make_shared<ChatMessageParser>(emoticons_, highlightManager_->getConfiguration(), ChatMessageParser::Mode::GroupChat); /* a message parser that knows this is a room/MUC (not a chat) */

+ controller = new MUCController(jid_, muc, password, nick, stanzaChannel_, iqRouter_, reuseChatwindow ? chatWindowFactoryAdapter : chatWindowFactory_, nickResolver_, presenceOracle_, avatarManager_, uiEventStream_, false, timerFactory_, eventController_, entityCapsProvider_, roster_, historyController_, mucRegistry_, highlightManager_, clientBlockListManager_, chatMessageParser, isImpromptu, autoAcceptMUCInviteDecider_, vcardManager_, mucBookmarkManager_);

+#include <Swift/Controllers/Highlighting/Highlighter.h>

+ NickResolver* nickResolver,

+ ChatControllerBase(self, stanzaChannel, iqRouter, chatWindowFactory, muc->getJID(), nickResolver, presenceOracle, avatarManager, useDelayForLatency, uiEventStream, eventController, timerFactory, entityCapsProvider, historyController, mucRegistry, highlightManager, chatMessageParser, autoAcceptMUCInviteDecider), muc_(muc), nick_(nick), desiredNick_(nick), password_(password), renameCounter_(0), isImpromptu_(isImpromptu), isImpromptuAlreadyConfigured_(false), clientBlockListManager_(clientBlockListManager), mucBookmarkManager_(mucBookmarkManager) {

+ chatMessageParser_->setNick(nick_);

+ highlighter_->handleSystemNotifications(chatMessage, messageEvent);

+ highlighter_->handleSoundNotifications(chatMessage);

+ chatMessageParser_->setNick(nick);

+ * Copyright (c) 2010-2017 Isode Limited.

+ MUCController(const JID& self, MUC::ref muc, const boost::optional<std::string>& password, const std::string &nick, StanzaChannel* stanzaChannel, IQRouter* iqRouter, ChatWindowFactory* chatWindowFactory, NickResolver* nickResolver, PresenceOracle* presenceOracle, AvatarManager* avatarManager, UIEventStream* events, bool useDelayForLatency, TimerFactory* timerFactory, EventController* eventController, EntityCapsProvider* entityCapsProvider, XMPPRoster* xmppRoster, HistoryController* historyController, MUCRegistry* mucRegistry, HighlightManager* highlightManager, ClientBlockListManager* clientBlockListManager, std::shared_ptr<ChatMessageParser> chatMessageParser, bool isImpromptu, AutoAcceptMUCInviteDecider* autoAcceptMUCInviteDecider, VCardManager* vcardManager, MUCBookmarkManager* mucBookmarkManager);

+ * Copyright (c) 2013-2017 Isode Limited.

+#include <gtest/gtest.h>

+#include <Swift/Controllers/Highlighting/HighlightConfiguration.h>

+#include <Swift/Controllers/Highlighting/HighlightManager.h>

+#include <Swift/Controllers/Settings/DummySettingsProvider.h>

+// Common test state

+class ChatMessageParserTest : public ::testing::Test {

+protected:

+ virtual void SetUp() {

+ virtual void TearDown() {

+ static void assertText(const ChatWindow::ChatMessage& result, size_t index, const std::string& text) {

+ ASSERT_LT(index, result.getParts().size());

+ ASSERT_EQ(text, part->text);

+ static void assertEmoticon(const ChatWindow::ChatMessage& result, size_t index, const std::string& text, const std::string& path) {

+ ASSERT_LT(index, result.getParts().size());

+ ASSERT_NE(nullptr, part);

+ ASSERT_EQ(text, part->alternativeText);

+ ASSERT_EQ(path, part->imagePath);

+ static void assertURL(const ChatWindow::ChatMessage& result, size_t index, const std::string& text) {

+ ASSERT_LT(index, result.getParts().size());

+ ASSERT_EQ(text, part->target);

+ void assertHighlight(const ChatWindow::ChatMessage& result, size_t index, const std::string& text, const HighlightAction& action) {

+ ASSERT_LT(index, result.getParts().size());

+ std::shared_ptr<ChatWindow::ChatHighlightingMessagePart> part = std::dynamic_pointer_cast<ChatWindow::ChatHighlightingMessagePart>(result.getParts()[index]);

+ ASSERT_EQ(std::string(text), part->text);

+ ASSERT_EQ(action, part->action);

+ static const std::shared_ptr<HighlightConfiguration> highlightConfigFromKeyword(const std::string& keyword, bool matchCase) {

+ std::shared_ptr<HighlightConfiguration> config = std::make_shared<HighlightConfiguration>();

+ HighlightConfiguration::KeywordHightlight keywordHighlight;

+ keywordHighlight.keyword = keyword;

+ keywordHighlight.matchCaseSensitive = matchCase;

+ keywordHighlight.action.setFrontColor(std::string("#121212"));

+ config->keywordHighlights.push_back(keywordHighlight);

+ return config;

+ static const std::shared_ptr<HighlightConfiguration> mergeHighlightConfig(const std::shared_ptr<HighlightConfiguration>& configA, const std::shared_ptr<HighlightConfiguration>& configB) {

+ std::shared_ptr<HighlightConfiguration> config = std::make_shared<HighlightConfiguration>();

+ config->keywordHighlights.insert(config->keywordHighlights.end(), configA->keywordHighlights.begin(), configA->keywordHighlights.end());

+ config->keywordHighlights.insert(config->keywordHighlights.end(), configB->keywordHighlights.begin(), configB->keywordHighlights.end());

+ return config;

+TEST_F(ChatMessageParserTest, testNoHighlightingWithEmtpyConfiguration) {

+ const std::string no_special_message = "a message with no special content";

+ ChatMessageParser testling(emoticons_, std::make_shared<HighlightConfiguration>());

+ auto result = testling.parseMessageBody(no_special_message);

+ assertText(result, 0, no_special_message);

+}

+

+TEST_F(ChatMessageParserTest, testSimpleHighlightAndEmojiAndUrlParsing) {

+ auto highlightConfig = highlightConfigFromKeyword("trigger", false);

+ auto testling = ChatMessageParser(emoticons_, highlightConfig);

+ auto result = testling.parseMessageBody(":) shiny :( trigger :) http://wonderland.lit/blah http://denmark.lit boom boom");

+ assertEmoticon(result, 0, smile1_, smile1Path_);

+ assertText(result, 1, " shiny ");

+ assertEmoticon(result, 2, smile2_, smile2Path_);

+ assertText(result, 3, " ");

+ assertHighlight(result, 4, "trigger", highlightConfig->keywordHighlights[0].action);

+ assertText(result, 5, " ");

+ assertEmoticon(result, 6, smile1_, smile1Path_);

+ assertText(result, 7, " ");

+ assertURL(result, 8, "http://wonderland.lit/blah");

+ assertText(result, 9, " ");

+ assertURL(result, 10, "http://denmark.lit");

+ assertText(result, 11, " boom boom");

+}

+

+TEST_F(ChatMessageParserTest, testNoKeywordHighlightAsPartOfLongerWords) {

+ auto testling = ChatMessageParser(emoticons_, highlightConfigFromKeyword("trigger", false));

+ auto result = testling.parseMessageBody("testtriggermessage");

+ assertText(result, 0, "testtriggermessage");

+}

+

+TEST_F(ChatMessageParserTest, testCaseInsensitiveKeyordHighlight) {

+ auto config = highlightConfigFromKeyword("trigger", true);

+ auto testling = ChatMessageParser(emoticons_, config);

+ auto result = testling.parseMessageBody("TrIgGeR");

+ assertText(result, 0, "TrIgGeR");

+

+ testling = ChatMessageParser(emoticons_, highlightConfigFromKeyword("trigger", false));

+ result = testling.parseMessageBody("TrIgGeR");

+ assertHighlight(result, 0, "TrIgGeR", config->keywordHighlights[0].action);

+}

+

+TEST_F(ChatMessageParserTest, testMultipleKeywordHighlights) {

+ auto config = mergeHighlightConfig(highlightConfigFromKeyword("one", false), highlightConfigFromKeyword("three", false));

+ auto testling = ChatMessageParser(emoticons_, config);

+ auto result = testling.parseMessageBody("zero one two three");

+ assertText(result, 0, "zero ");

+ assertHighlight(result, 1, "one", config->keywordHighlights[0].action);

+ assertText(result, 2, " two ");

+ assertHighlight(result, 3, "three", config->keywordHighlights[0].action);

+}

+

+TEST_F(ChatMessageParserTest, testMultipleCaseInsensitiveKeywordHighlights) {

+ auto config = mergeHighlightConfig(highlightConfigFromKeyword("one", false), highlightConfigFromKeyword("three", false));

+ auto testling = ChatMessageParser(emoticons_, config);

+ auto result = testling.parseMessageBody("zero oNe two tHrEe");

+ assertText(result, 0, "zero ");

+ assertHighlight(result, 1, "oNe", config->keywordHighlights[0].action);

+ assertText(result, 2, " two ");

+ assertHighlight(result, 3, "tHrEe", config->keywordHighlights[0].action);

+}

+

+TEST_F(ChatMessageParserTest, testMultipleCaseSensitiveKeywordHighlights) {

+ auto config = mergeHighlightConfig(highlightConfigFromKeyword("one", false), highlightConfigFromKeyword("three", true));

+ auto testling = ChatMessageParser(emoticons_, config);

+ auto result = testling.parseMessageBody("zero oNe two tHrEe");

+ assertText(result, 0, "zero ");

+ assertHighlight(result, 1, "oNe", config->keywordHighlights[0].action);

+ assertText(result, 2, " two tHrEe");

+

+ config = mergeHighlightConfig(highlightConfigFromKeyword("one", true), highlightConfigFromKeyword("three", false));

+ testling = ChatMessageParser(emoticons_, config);

+ result = testling.parseMessageBody("zero oNe two tHrEe");

+ assertText(result, 0, "zero oNe two ");

+ assertHighlight(result, 1, "tHrEe", config->keywordHighlights[0].action);

+}

+

+TEST_F(ChatMessageParserTest, testOneEmoticon) {

+ auto testling = ChatMessageParser(emoticons_, std::make_shared<HighlightConfiguration>());

+ auto result = testling.parseMessageBody(" :) ");

+ assertText(result, 0, " ");

+ assertEmoticon(result, 1, smile1_, smile1Path_);

+ assertText(result, 2, " ");

+}

+

+TEST_F(ChatMessageParserTest, testBareEmoticon) {

+ auto testling = ChatMessageParser(emoticons_, std::make_shared<HighlightConfiguration>());

+ auto result = testling.parseMessageBody(":)");

+ assertEmoticon(result, 0, smile1_, smile1Path_);

+}

+

+TEST_F(ChatMessageParserTest, testHiddenEmoticon) {

+ auto testling = ChatMessageParser(emoticons_, std::make_shared<HighlightConfiguration>());

+ auto result = testling.parseMessageBody("b:)a");

+ assertText(result, 0, "b:)a");

+}

+

+TEST_F(ChatMessageParserTest, testEndlineEmoticon) {

+ auto testling = ChatMessageParser(emoticons_, std::make_shared<HighlightConfiguration>());

+ auto result = testling.parseMessageBody("Lazy:)");

+ assertText(result, 0, "Lazy");

+ assertEmoticon(result, 1, smile1_, smile1Path_);

+}

+

+TEST_F(ChatMessageParserTest, testBoundedEmoticons) {

+ auto testling = ChatMessageParser(emoticons_, std::make_shared<HighlightConfiguration>());

+ auto result = testling.parseMessageBody(":)Lazy:(");

+ assertEmoticon(result, 0, smile1_, smile1Path_);

+ assertText(result, 1, "Lazy");

+ assertEmoticon(result, 2, smile2_, smile2Path_);

+}

+

+TEST_F(ChatMessageParserTest, testEmoticonParenthesis) {

+ auto testling = ChatMessageParser(emoticons_, std::make_shared<HighlightConfiguration>());

+ auto result = testling.parseMessageBody("(Like this :))");

+ assertText(result, 0, "(Like this ");

+ assertEmoticon(result, 1, smile1_, smile1Path_);

+ assertText(result, 2, ")");

+}

+

+TEST_F(ChatMessageParserTest, testSenderAndKeywordHighlighting) {

+ auto config = std::make_shared<HighlightConfiguration>();

+ auto contactHighlight = HighlightConfiguration::ContactHighlight();

+ contactHighlight.action.setFrontColor(std::string("#f0f0f0"));

+ contactHighlight.action.setBackColor(std::string("#0f0f0f"));

+ contactHighlight.name = "Romeo";

+ config->contactHighlights.push_back(contactHighlight);

+ auto keywordHighlight = HighlightConfiguration::KeywordHightlight();

+ keywordHighlight.action.setFrontColor(std::string("#abcdef"));

+ keywordHighlight.action.setBackColor(std::string("#fedcba"));

+ keywordHighlight.keyword = "XMPP";

+ config->keywordHighlights.push_back(keywordHighlight);

+ auto testling = ChatMessageParser(emoticons_, config);

+ auto result = testling.parseMessageBody("Heard any news about xmpp recently?", "Romeo");

+ assertText(result, 0, "Heard any news about ");

+ assertHighlight(result, 1, "xmpp", keywordHighlight.action);

+ assertText(result, 2, " recently?");

+ ASSERT_EQ(contactHighlight.action, result.getHighlightActionSender());

+ ASSERT_EQ(HighlightAction(), result.getHighlightActionOwnMention());

+}

+

+TEST_F(ChatMessageParserTest, testKeywordWithEmptyActionIsIgnored) {

+ auto config = std::make_shared<HighlightConfiguration>();

+ auto keywordHighlight = HighlightConfiguration::KeywordHightlight();

+ keywordHighlight.keyword = "XMPP";

+ config->keywordHighlights.push_back(keywordHighlight);

+ auto testling = ChatMessageParser(emoticons_, config);

+ auto result = testling.parseMessageBody("Heard any news about xmpp recently?", "Romeo");

+ assertText(result, 0, "Heard any news about xmpp recently?");

+ ASSERT_EQ(HighlightAction(), result.getHighlightActionOwnMention());

+}

+

+TEST_F(ChatMessageParserTest, testMeMessageAndOwnMention) {

+ auto config = std::make_shared<HighlightConfiguration>();

+ config->ownMentionAction.setFrontColor(std::string("#f0f0f0"));

+ config->ownMentionAction.setBackColor(std::string("#0f0f0f"));

+ config->ownMentionAction.setSoundFilePath(std::string("someSoundFile.wav"));

+ auto ownMentionActionForPart = config->ownMentionAction;

+ ownMentionActionForPart.setSoundFilePath(boost::optional<std::string>());

+ auto testling = ChatMessageParser(emoticons_, config);

+ testling.setNick("Juliet");

+ auto result = testling.parseMessageBody("/me wonders when Juliet is coming?", "Romeo");

+ assertText(result, 0, "wonders when ");

+ assertHighlight(result, 1, "Juliet", ownMentionActionForPart);

+ assertText(result, 2, " is coming?");

+ ASSERT_EQ(true, result.isMeCommand());

+ ASSERT_EQ(config->ownMentionAction, result.getHighlightActionOwnMention());

+}

+

+TEST_F(ChatMessageParserTest, testSoundAndNotificationOnDirectMessage) {

+ auto defaultConfiguration = std::make_shared<HighlightConfiguration>();

+ defaultConfiguration->playSoundOnIncomingDirectMessages = true;

+ defaultConfiguration->showNotificationOnIncomingDirectMessages = true;

+ defaultConfiguration->ownMentionAction.setFrontColor(std::string("black"));

+ defaultConfiguration->ownMentionAction.setBackColor(std::string("yellow"));

+ defaultConfiguration->ownMentionAction.setSoundFilePath(std::string(""));

+ defaultConfiguration->ownMentionAction.setSystemNotificationEnabled(true);

+

+ auto testling = ChatMessageParser(emoticons_, defaultConfiguration, ChatMessageParser::Mode::Chat);

+ auto result = testling.parseMessageBody("I wonder when Juliet is coming?", "Romeo");

+

+ ASSERT_EQ(std::string(""), result.getHighlightActionDirectMessage().getSoundFilePath().get_value_or(std::string("somethingElse")));

+ ASSERT_EQ(true, result.getHighlightActionDirectMessage().isSystemNotificationEnabled());

+ ASSERT_EQ(HighlightAction(), result.getHighlightActionOwnMention());

+}

+

+TEST_F(ChatMessageParserTest, testWithDefaultConfiguration) {

+ DummySettingsProvider settings;

+ HighlightManager manager(&settings);

+ manager.resetToDefaultConfiguration();

+ auto testling = ChatMessageParser(emoticons_, manager.getConfiguration(), ChatMessageParser::Mode::GroupChat);

+ testling.setNick("Juliet");

+ auto result = testling.parseMessageBody("Hello, how is it going?", "Romeo");

+ assertText(result, 0, "Hello, how is it going?");

+ ASSERT_EQ(HighlightAction(), result.getHighlightActionOwnMention());

+ ASSERT_EQ(HighlightAction(), result.getHighlightActionDirectMessage());

+ ASSERT_EQ(HighlightAction(), result.getHighlightActionGroupMessage());

+ ASSERT_EQ(HighlightAction(), result.getHighlightActionSender());

+

+ result = testling.parseMessageBody("Juliet, seen the new interface design?", "Romeo");

+ auto mentionKeywordAction = manager.getConfiguration()->ownMentionAction;

+ mentionKeywordAction.setSoundFilePath(boost::optional<std::string>());

+ mentionKeywordAction.setSystemNotificationEnabled(false);

+ assertHighlight(result, 0, "Juliet", mentionKeywordAction);

+ assertText(result, 1, ", seen the new interface design?");

+ ASSERT_EQ(manager.getConfiguration()->ownMentionAction, result.getHighlightActionOwnMention());

+ ASSERT_EQ(HighlightAction(), result.getHighlightActionDirectMessage());

+ ASSERT_EQ(HighlightAction(), result.getHighlightActionGroupMessage());

+ ASSERT_EQ(HighlightAction(), result.getHighlightActionSender());

+}

+ * Copyright (c) 2010-2017 Isode Limited.

+ highlightManager_->resetToDefaultConfiguration();

+ HighlightConfiguration::KeywordHightlight keywordRuleA;

+ keywordRuleA.keyword = "Romeo";

+ keywordRuleA.action.setFrontColor(boost::optional<std::string>("yellow"));

+ keywordRuleA.action.setSoundFilePath(boost::optional<std::string>(""));

+ highlightManager_->getConfiguration()->keywordHighlights.push_back(keywordRuleA);

+

+ HighlightConfiguration::KeywordHightlight keywordRuleB;

+ keywordRuleB.keyword = "Juliet";

+ keywordRuleB.action.setFrontColor(boost::optional<std::string>("green"));

+ keywordRuleB.action.setSoundFilePath(boost::optional<std::string>("/tmp/someotherfile.wav"));

+ highlightManager_->getConfiguration()->keywordHighlights.push_back(keywordRuleB);

+ CPPUNIT_ASSERT(soundsPlayed_.find(keywordRuleA.action.getSoundFilePath().get_value_or("")) != soundsPlayed_.end());

+ CPPUNIT_ASSERT(soundsPlayed_.find(keywordRuleB.action.getSoundFilePath().get_value_or("")) != soundsPlayed_.end());

+ auto keywordRuleA = HighlightConfiguration::KeywordHightlight();

+ keywordRuleA.keyword = "Romeo";

+ keywordRuleA.action.setFrontColor(boost::optional<std::string>("yellow"));

+ keywordRuleA.action.setSoundFilePath(boost::optional<std::string>(""));

+ highlightManager_->getConfiguration()->keywordHighlights.push_back(keywordRuleA);

+

+ auto keywordRuleB = HighlightConfiguration::KeywordHightlight();

+ keywordRuleB.keyword = "Juliet";

+ keywordRuleB.action.setFrontColor(boost::optional<std::string>("green"));

+ keywordRuleB.action.setSoundFilePath(boost::optional<std::string>(""));

+ highlightManager_->getConfiguration()->keywordHighlights.push_back(keywordRuleB);

+ CPPUNIT_ASSERT(soundsPlayed_.find(keywordRuleA.action.getSoundFilePath().get_value_or("")) != soundsPlayed_.end());

+ CPPUNIT_ASSERT(soundsPlayed_.find(keywordRuleB.action.getSoundFilePath().get_value_or("")) != soundsPlayed_.end());

+ //highlightManager_->resetToDefaultConfiguration();

+

+ HighlightConfiguration::KeywordHightlight keywordHighlight;

+ keywordHighlight.keyword = "foo";

+ keywordHighlight.action.setBackColor(boost::optional<std::string>("green"));

+ highlightManager_->getConfiguration()->keywordHighlights.push_back(keywordHighlight);

+ if (action.getSoundFilePath()) {

+ soundsPlayed_.insert(action.getSoundFilePath().get_value_or(""));

+ * Copyright (c) 2010-2017 Isode Limited.

+ chatMessageParser_ = std::make_shared<ChatMessageParser>(std::map<std::string, std::string>(), highlightManager_->getConfiguration(), ChatMessageParser::Mode::GroupChat);

+ nickResolver_ = new NickResolver(self_, xmppRoster_, vcardManager_, mucRegistry_);

+ controller_ = new MUCController (self_, muc_, boost::optional<std::string>(), nick_, stanzaChannel_, iqRouter_, chatWindowFactory_, nickResolver_, presenceOracle_, avatarManager_, uiEventStream_, false, timerFactory, eventController_, entityCapsProvider_, nullptr, nullptr, mucRegistry_, highlightManager_, clientBlockListManager_, chatMessageParser_, false, nullptr, vcardManager_, mucBookmarkManager_);

+ delete nickResolver_;

+ NickResolver* nickResolver_;