Publishing now has a space for an article and a title. Also reduced amount of copying

component/router.cpp

@@ -3,6 +3,8 @@
 
 #include "router.h"
 
+#include <string_view>
+
 #include "module/module.h"
 #include "connection/connection.h"
 
@@ -42,12 +44,23 @@ void Router::routeMessage(const std::string& sender, const std::string& body) {
     if (aItr == actors.end())
         aItr = actors.emplace(sender, std::make_shared<Actor>(sender, defaultGroup)).first;
 
-    Shared::Strings args = Shared::split(body);
+    std::string_view view(body);
-    std::string moduleAlias = Module::Module::lower(args[0]);
+    std::string_view aliasView = Module::Module::pop(view);
+    
+    if (aliasView.size() > 1000)  {
+        warn("Received a message with the first word larger than 1000 symbols, " + sender + "is clearly looking for a vulnerability");
+        return onMessageResult(Shared::unhandled, sender);
+    }
 
-    Modules::iterator mItr = modules.find(moduleAlias);
+    if (view.empty()) {
+        debug("Incoming message from " + sender + " consists of only one word, modules have nothing to process");
+        return onMessageResult(Shared::unhandled, sender);
+    }
+
+    std::string alias(aliasView);
+    Modules::iterator mItr = modules.find(alias);
     if (mItr == modules.end()) {
-        debug("could not find module \"" + moduleAlias + "\" to handle message from " + sender);
+        debug("could not find module \"" + alias + "\" to handle message from " + sender);
         return onMessageResult(Shared::unhandled, sender);
     }
 
@@ -57,10 +70,9 @@ void Router::routeMessage(const std::string& sender, const std::string& body) {
         return onMessageResult(Shared::error, sender);
     }
 
-    args.erase(args.begin());
     Shared::Result result;
     try {
-        result = module->message(aItr->second, args);
+        result = module->message(aItr->second, view);
         if (result == Shared::success)
         debug("module \"" + mItr->first + "\" successfully handled message from " + sender);
     } catch (...) {

connection/connection.cpp

@@ -76,7 +76,7 @@ void Connection::publish(const std::string& service, const std::string& node, co
 
     entry->addChild(new gloox::Tag("id", "urn:uuid:" + Shared::getUUID()));
     entry->addChild(new gloox::Tag("title", title));
-    entry->addChild(new gloox::Tag("summary", body));
+    entry->addChild(new gloox::Tag("content", body));
     entry->addChild(new gloox::Tag("updated", Shared::getISOTimestamp()));
     entry->addChild(new gloox::Tag("published", Shared::getISOTimestamp()));
 

module/actor.cpp

@@ -9,26 +9,27 @@ Module::Actor::Actor(const std::shared_ptr<Core>& core, const Config::Module& co
 
 Module::Actor::~Actor() noexcept {}
 
-Shared::Result Module::Actor::message(const std::shared_ptr<::Actor>& actor, const Shared::Strings& args) {
+Shared::Result Module::Actor::message(const std::shared_ptr<::Actor>& actor, std::string_view view) {
-    std::string result;
+    std::string_view command = pop(view);
 
-    if (args.front() == "list") {
+    if (command == "list") {
         if (!hasPermission("read", actor))
             return Shared::forbidden;
             
-        result = list();
+        core->send(actor->jid, list());
-    } else if (args.front() == "set") {
+        return Shared::success;
+    } 
+
+    if (command == "set") {
         if (!hasPermission("write", actor))
             return Shared::forbidden;
         
-        if (args.size() < 3)
+        std::string_view jid = pop(view);
+        std::string_view group = pop(view);
+        if (jid.empty() || group.empty())
             return Shared::error;
 
-        result = set(args[1], args[2]);
+        core->send(actor->jid, set(jid, group));
-    }
-
-    if (!result.empty()) {
-        core->send(actor->jid, result);
         return Shared::success;
     }
 
@@ -50,8 +51,11 @@ std::string Module::Actor::list() {
     return result;
 }
 
-std::string Module::Actor::set(const std::string& jid, const std::string& group) {
+std::string Module::Actor::set(const std::string_view& jid, const std::string_view& group) {
-    core->setGroup(lower(jid), group);
+    std::string j(lower(std::string(jid)));
+    std::string g(group);
+    
+    core->setGroup(j, g);
 
-    return jid + " is now " + core->router.getGroup(jid);
+    return j + " is now " + core->router.getGroup(j);
 }

module/actor.h

@@ -14,11 +14,11 @@ public:
     Actor(const std::shared_ptr<Core>& core, const Config::Module& conf);
     ~Actor() noexcept;
 
-    virtual Shared::Result message(const std::shared_ptr<::Actor>& actor, const Shared::Strings& args) override;
+    virtual Shared::Result message(const std::shared_ptr<::Actor>& actor, std::string_view view) override;
 
 private:
     std::string list();
-    std::string set(const std::string& jid, const std::string& group);
+    std::string set(const std::string_view& jid, const std::string_view& group);
 };
 
 }

module/module.cpp

@@ -28,3 +28,22 @@ Module::Module::~Module() noexcept {}
 std::string Module::Module::lower(const std::string& text) {
     return std::ranges::to<std::string>(text | std::views::transform(::tolower));
 }
+
+std::string_view Module::Module::pop(std::string_view& input, char delimiter) {
+    std::size_t pos = input.find(delimiter);
+    std::string_view token;
+
+    if (pos == std::string_view::npos) {
+        token = input;
+        input = {};
+    } else {
+        token = input.substr(0, pos);
+        pos = input.find_first_not_of(' ', pos + 1);
+        if (pos == std::string_view::npos)
+            input = {};
+        else 
+            input.remove_prefix(pos);
+    }
+
+    return token;
+}

module/module.h

@@ -8,6 +8,7 @@
 #include <vector>
 #include <ranges>
 #include <cctype>
+#include <string_view>
 
 #include "shared/definitions.h"
 #include "shared/result.h"
@@ -28,8 +29,9 @@ public:
     virtual ~Module() noexcept;
 
     static std::string lower(const std::string& text);
+    static std::string_view pop(std::string_view& input, char delimiter = ' ');
 
-    virtual Shared::Result message(const std::shared_ptr<::Actor>& actor, const Shared::Strings& args) = 0;
+    virtual Shared::Result message(const std::shared_ptr<::Actor>& actor, std::string_view view) = 0;
 
 public:
     const std::string name;

module/publish.cpp

@@ -11,29 +11,33 @@ Module::Publish::Publish(const std::shared_ptr<Core>& core, const Config::Module
 
 Module::Publish::~Publish() noexcept {}
 
-Shared::Result Module::Publish::message(const std::shared_ptr<::Actor>& actor, const Shared::Strings& args) {
+Shared::Result Module::Publish::message(const std::shared_ptr<::Actor>& actor, std::string_view view) {
-    if (args.front() == "to") {
+    std::string_view command = pop(view);
+
+    if (command == "to") {
         if (!hasPermission("publish", actor))
             return Shared::forbidden;
-            
+        
-        if (args.size() < 3)
+        std::string_view head = pop(view, '\n');
+        std::string_view address = pop(head);
+        if (address.empty())
             return Shared::error;
 
-        return to(args[1], args[2]);
+        return to(address, head, view);
     }
 
     return Shared::unhandled;
 }
 
-Shared::Result Module::Publish::to(const std::string& address, const std::string& body) {
+Shared::Result Module::Publish::to(std::string_view address, std::string_view title, std::string_view body) {
-    Shared::Strings parts = Shared::split(address, "@");
+    std::string_view node = pop(address, '@');
-    if (parts.size() != 2) {
+    if (node.empty() || address.empty()) {
         warn("Malformed address in \"to\" method");
         return Shared::error;
     }
 
     try {
-        core->publish(parts[1], parts[0], "Completely testing stuff, early stages, ignore please", body);
+        core->publish(std::string(address), std::string(node), std::string(title), std::string(body));
         return Shared::success;
     } catch (const std::exception& e) {
         error("Exception in \"to\" method: " + std::string(e.what()));

module/publish.h

@@ -16,10 +16,10 @@ public:
     Publish(const std::shared_ptr<Core>& core, const Config::Module& conf);
     ~Publish() noexcept;
 
-    virtual Shared::Result message(const std::shared_ptr<::Actor>& actor, const Shared::Strings& args) override;
+    virtual Shared::Result message(const std::shared_ptr<::Actor>& actor, std::string_view view) override;
 
 private:
-    Shared::Result to(const std::string& address, const std::string& body);
+    Shared::Result to(std::string_view address, std::string_view title, std::string_view body);
 };
 
 }