Replaced Json parser with a custom one (optims+compact output)

src/libs/subsonic/impl/SubsonicResource.cpp

@@ -290,10 +290,11 @@ namespace API::Subsonic
 
                 Response resp{ (itEntryPoint->second.func)(requestContext) };
 
+                LMS_LOG(API_SUBSONIC, DEBUG) << "Request " << requestId << " '" << requestPath << "' handled!";
                 resp.write(response.out(), format);
                 response.setMimeType(std::string{ ResponseFormatToMimeType(format) });
+                LMS_LOG(API_SUBSONIC, DEBUG) << "Request " << requestId << " '" << requestPath << "' written!";
 
-                LMS_LOG(API_SUBSONIC, DEBUG) << "Request " << requestId << " '" << requestPath << "' handled!";
                 return;
             }
 

src/libs/subsonic/impl/SubsonicResponse.cpp

@@ -20,12 +20,8 @@
 #include "SubsonicResponse.hpp"
 
 #include <cassert>
-#include <Wt/Json/Array.h>
+#include <cmath>
-#include <Wt/Json/Object.h>
+#include <climits>
-#include <Wt/Json/Value.h>
-#include <Wt/Json/Serializer.h>
-
-#include <boost/property_tree/json_parser.hpp>
 #include <boost/property_tree/xml_parser.hpp>
 
 #include "utils/Exception.hpp"
@@ -57,59 +53,66 @@ namespace API::Subsonic
         _value = value;
     }
 
-    void Response::Node::setAttribute(std::string_view key, std::string_view value)
+    void Response::Node::setAttribute(Key key, std::string_view value)
     {
-        _attributes[std::string{ key }] = std::string{ value };
+        _attributes[key] = std::string{ value };
     }
 
-    void Response::Node::addChild(const std::string& key, Node node)
+    void Response::Node::addChild(Key key, Node node)
     {
         assert(!_value);
-        _children[key].emplace_back(std::move(node));
+        assert(_children.find(key) == std::cend(_children));
+        _children[key] = std::move(node);
     }
 
-    void Response::Node::createEmptyArrayChild(std::string_view key)
+    void Response::Node::createEmptyArrayChild(Key key)
     {
         assert(!_value);
+        assert(_children.find(key) == std::cend(_children));
         _childrenArrays.emplace(key, std::vector<Node>{});
     }
 
-    void Response::Node::addArrayChild(std::string_view key, Node node)
+    void Response::Node::addArrayChild(Key key, Node node)
     {
         assert(!_value);
-        _childrenArrays[std::string{ key }].emplace_back(std::move(node));
+        assert(_children.find(key) == std::cend(_children));
+        _childrenArrays[key].emplace_back(std::move(node));
     }
 
-    void Response::Node::createEmptyArrayValue(std::string_view key)
+    void Response::Node::createEmptyArrayValue(Key key)
     {
         assert(!_value);
+        assert(_children.find(key) == std::cend(_children));
         _childrenValues.emplace(key, ValuesType{});
     }
 
-    void Response::Node::addArrayValue(std::string_view key, std::string_view value)
+    void Response::Node::addArrayValue(Key key, std::string_view value)
     {
         assert(!_value);
-        auto& values{ _childrenValues[std::string{ key }] };
+        assert(_children.find(key) == std::cend(_children));
+        auto& values{ _childrenValues[key] };
         values.push_back(std::string{ value });
         assert(std::all_of(std::cbegin(values) + 1, std::cend(values), [&](const ValueType& value) {return value.index() == values.front().index();}));
     }
 
-    void Response::Node::addArrayValue(std::string_view key, long long value)
+    void Response::Node::addArrayValue(Key key, long long value)
     {
         assert(!_value);
-        auto& values{ _childrenValues[std::string{ key }] };
+        auto& values{ _childrenValues[key] };
         values.push_back(value);
         assert(std::all_of(std::cbegin(values) + 1, std::cend(values), [&](const ValueType& value) {return value.index() == values.front().index();}));
     }
 
-    Response::Node& Response::Node::createChild(const std::string& key)
+    Response::Node& Response::Node::createChild(Key key)
     {
-        _children[key].emplace_back();
+        assert(!_value);
-        return _children[key].back();
+        return _children[key];
     }
 
-    Response::Node& Response::Node::createArrayChild(const std::string& key)
+    Response::Node& Response::Node::createArrayChild(Key key)
     {
+        assert(!_value);
+        assert(_children.find(key) == std::cend(_children));
         _childrenArrays[key].emplace_back();
         return _childrenArrays[key].back();
     }
@@ -152,19 +155,19 @@ namespace API::Subsonic
         return response;
     }
 
-    void Response::addNode(const std::string& key, Node node)
+    void Response::addNode(Node::Key key, Node node)
     {
-        return _root._children["subsonic-response"].front().addChild(key, std::move(node));
+        return _root._children["subsonic-response"].addChild(key, std::move(node));
     }
 
-    Response::Node& Response::createNode(const std::string& key)
+    Response::Node& Response::createNode(Node::Key key)
     {
-        return _root._children["subsonic-response"].front().createChild(key);
+        return _root._children["subsonic-response"].createChild(key);
     }
 
-    Response::Node& Response::createArrayNode(const std::string& key)
+    Response::Node& Response::createArrayNode(Node::Key key)
     {
-        return _root._children["subsonic-response"].front().createArrayChild(key);
+        return _root._children["subsonic-response"].createArrayChild(key);
     }
 
     void Response::write(std::ostream& os, ResponseFormat format)
@@ -186,16 +189,16 @@ namespace API::Subsonic
             {
                 boost::property_tree::ptree res;
 
-                for (auto itAttribute : node._attributes)
+                for (const auto& [key, value] : node._attributes)
                 {
-                    if (std::holds_alternative<std::string>(itAttribute.second))
+                    if (std::holds_alternative<std::string>(value))
-                        res.put("<xmlattr>." + itAttribute.first, std::get<std::string>(itAttribute.second));
+                        res.put("<xmlattr>." + std::string{ key.get() }, std::get<std::string>(value));
-                    else if (std::holds_alternative<bool>(itAttribute.second))
+                    else if (std::holds_alternative<bool>(value))
-                        res.put("<xmlattr>." + itAttribute.first, std::get<bool>(itAttribute.second));
+                        res.put("<xmlattr>." + std::string{ key.get() }, std::get<bool>(value));
-                    else if (std::holds_alternative<float>(itAttribute.second))
+                    else if (std::holds_alternative<float>(value))
-                        res.put("<xmlattr>." + itAttribute.first, std::get<float>(itAttribute.second));
+                        res.put("<xmlattr>." + std::string{ key.get() }, std::get<float>(value));
-                    else if (std::holds_alternative<long long>(itAttribute.second))
+                    else if (std::holds_alternative<long long>(value))
-                        res.put("<xmlattr>." + itAttribute.first, std::get<long long>(itAttribute.second));
+                        res.put("<xmlattr>." + std::string{ key.get() }, std::get<long long>(value));
                 }
 
                 auto valueToPropertyTree = [](const Node::ValueType& value)
@@ -215,22 +218,21 @@ namespace API::Subsonic
                 }
                 else
                 {
-                    for (const auto& [key, childNodes] : node._children)
+                    for (const auto& [key, childNode] : node._children)
                     {
-                        for (const Node& childNode : childNodes)
+                        res.add_child(std::string{ key.get() }, nodeToPropertyTree(childNode));
-                            res.add_child(key, nodeToPropertyTree(childNode));
                     }
 
                     for (const auto& [key, childArrayNodes] : node._childrenArrays)
                     {
                         for (const Node& childNode : childArrayNodes)
-                            res.add_child(key, nodeToPropertyTree(childNode));
+                            res.add_child(std::string{ key.get() }, nodeToPropertyTree(childNode));
                     }
 
                     for (const auto& [key, childArrayValues] : node._childrenValues)
                     {
                         for (const Response::Node::ValueType& value : childArrayValues)
-                            res.add_child(key, valueToPropertyTree(value));
+                            res.add_child(std::string{ key.get() }, valueToPropertyTree(value));
                     }
                 }
 
@@ -241,63 +243,137 @@ namespace API::Subsonic
         boost::property_tree::write_xml(os, root);
     }
 
+    void Response::JsonSerializer::serializeNode(std::ostream& os, const Response::Node& node)
+    {
+        os << '{';
+
+        bool first{ true };
+
+        for (const auto& [key, value] : node._attributes)
+        {
+            if (!first)
+                os << ',';
+
+            serializeEscapedString(os, key.get());
+            os << ':';
+            serializeValue(os, value);
+
+            first = false;
+        }
+
+        if (node._value)
+        {
+            if (!first)
+                os << ',';
+
+            os << "value:";
+            serializeValue(os, *node._value);
+
+            first = false;
+        }
+        else
+        {
+            for (const auto& [key, childNode] : node._children)
+            {
+                if (!first)
+                    os << ',';
+
+                serializeEscapedString(os, key.get());
+                os << ':';
+                serializeNode(os, childNode);
+
+                first = false;
+            }
+
+
+            for (const auto& [key, childArrayNodes] : node._childrenArrays)
+            {
+                if (!first)
+                    os << ',';
+
+                serializeEscapedString(os, key.get());
+                os << ":[";
+
+                bool firstChild{ true };
+                for (const Response::Node& childNode : childArrayNodes)
+                {
+                    if (!firstChild)
+                        os << ",";
+
+                    serializeNode(os, childNode);
+                    firstChild = false;
+                }
+                os << ']';
+
+                first = false;
+            }
+
+            for (const auto& [key, childValues] : node._childrenValues)
+            {
+                if (!first)
+                    os << ',';
+
+                serializeEscapedString(os, key.get());
+                os << ":[";
+
+                bool firstChild{ true };
+                for (const Node::ValueType& childValue : childValues)
+                {
+                    if (!firstChild)
+                        os << ",";
+
+                    serializeValue(os, childValue);
+
+                    firstChild = false;
+                }
+                os << ']';
+
+                first = false;
+            }
+        }
+
+        os << '}';
+    }
+
+    void Response::JsonSerializer::serializeValue(std::ostream& os, const Node::ValueType& value)
+    {
+        if (std::holds_alternative<std::string>(value))
+        {
+            serializeEscapedString(os, std::get<std::string>(value));
+        }
+        else if (std::holds_alternative<bool>(value))
+        {
+            os << (std::get<bool>(value) ? "true" : "false");
+        }
+        else if (std::holds_alternative<float>(value))
+        {
+            const float d{ std::get<float>(value) };
+            if (std::isnan(d) || std::fabs(d) == std::numeric_limits<float>::infinity())
+                os << "null";
+            else
+                os << d;
+        }
+        else if (std::holds_alternative<long long>(value))
+        {
+            os << std::get<long long>(value);
+        }
+        else
+        {
+            assert(false);
+        }
+    }
+
+    void Response::JsonSerializer::serializeEscapedString(std::ostream& os, std::string_view str)
+    {
+        os << '\"';
+        StringUtils::writeJSEscapedString(os, str);
+        os << '\"';
+    }
+
     void Response::writeJSON(std::ostream& os)
     {
-        namespace Json = Wt::Json;
+        JsonSerializer serializer;
-
+        serializer.serializeNode(os, _root);
-        std::function<Json::Object(const Response::Node&)> nodeToJsonObject = [&](const Response::Node& node)
-            {
-                Json::Object res;
-
-                auto valueToJsonValue{ [](const Node::ValueType& value) -> Json::Value
-                {
-                    Json::Value res;
-                    std::visit([&](const auto& rawValue)
-                    {
-                        res = Json::Value{ rawValue };
-                    }, value);
-                    return res;
-                } };
-
-                for (auto itAttribute : node._attributes)
-                    res[itAttribute.first] = valueToJsonValue(itAttribute.second);
-
-                if (node._value)
-                {
-                    res["value"] = valueToJsonValue(*node._value);
-                }
-                else
-                {
-                    for (const auto& [key, childNodes] : node._children)
-                    {
-                        for (const Response::Node& childNode : childNodes)
-                            res[key] = nodeToJsonObject(childNode);
-                    }
-
-                    for (const auto& [key, childArrayNodes] : node._childrenArrays)
-                    {
-                        Json::Array array;
-                        for (const Response::Node& childNode : childArrayNodes)
-                            array.emplace_back(nodeToJsonObject(childNode));
-
-                        res[key] = std::move(array);
-                    }
-
-                    for (const auto& [key, childValues] : node._childrenValues)
-                    {
-                        Json::Array array;
-                        for (const Node::ValueType& childValue : childValues)
-                            array.emplace_back(valueToJsonValue(childValue));
-
-                        res[key] = std::move(array);
-                    }
-                }
-
-                return res;
-            };
-
-        Json::Object root{ nodeToJsonObject(_root) };
-        os << Json::serialize(root);
     }
 
 } // namespace

src/libs/subsonic/impl/SubsonicResponse.hpp

@@ -191,17 +191,30 @@ namespace API::Subsonic
         class Node
         {
         public:
-            void setAttribute(std::string_view key, std::string_view value);
+            class Key
+            {
+            public:
+                template<std::size_t N>
+                constexpr Key(const char (&str)[N]) : _str{ str } {}
+                constexpr std::string_view get() const { return _str; }
+
+                bool constexpr operator<(const Key& other) const { return _str < other._str; }
+
+            private:
+                const std::string_view _str;
+            };
+
+            void setAttribute(Key key, std::string_view value);
 
             template <typename T, std::enable_if_t<std::is_arithmetic<T>::value>* = nullptr>
-            void setAttribute(std::string_view key, T value)
+            void setAttribute(Key key, T value)
             {
                 if constexpr (std::is_same<bool, T>::value)
-                    _attributes[std::string{ key }] = value;
+                    _attributes[key] = value;
                 else if constexpr (std::is_floating_point<T>::value)
-                    _attributes[std::string{ key }] = static_cast<float>(value);
+                    _attributes[key] = static_cast<float>(value);
                 else if constexpr (std::is_integral<T>::value)
-                    _attributes[std::string{ key }] = static_cast<long long>(value);
+                    _attributes[key] = static_cast<long long>(value);
                 else
                     static_assert("Unhandled type");
             }
@@ -209,28 +222,28 @@ namespace API::Subsonic
             // A Node has either a single value or an array of values or some children
             void setValue(std::string_view value);
             void setValue(long long value);
-            Node& createChild(const std::string& key);
+            Node& createChild(Key key);
-            Node& createArrayChild(const std::string& key);
+            Node& createArrayChild(Key key);
 
-            void addChild(const std::string& key, Node node);
+            void addChild(Key key, Node node);
-            void createEmptyArrayChild(std::string_view key);
+            void createEmptyArrayChild(Key key);
-            void addArrayChild(std::string_view key, Node node);
+            void addArrayChild(Key key, Node node);
-            void createEmptyArrayValue(std::string_view key);
+            void createEmptyArrayValue(Key key);
-            void addArrayValue(std::string_view key, std::string_view value);
+            void addArrayValue(Key key, std::string_view value);
-            void addArrayValue(std::string_view key, long long value);
+            void addArrayValue(Key key, long long value);
 
         private:
             void setVersionAttribute(ProtocolVersion version);
 
             friend class Response;
             using ValueType = std::variant<std::string, bool, float, long long>;
-            std::map<std::string, ValueType> _attributes;
+            std::map<Key, ValueType> _attributes;
             std::optional<ValueType> _value;
-            std::map<std::string, std::vector<Node>> _children;
+            std::map<Key, Node> _children;
-            std::map<std::string, std::vector<Node>> _childrenArrays;
+            std::map<Key, std::vector<Node>> _childrenArrays;
 
             using ValuesType = std::vector<ValueType>;
-            std::map<std::string, ValuesType> _childrenValues;
+            std::map<Key, ValuesType> _childrenValues;
         };
 
         static Response createOkResponse(ProtocolVersion protocolVersion);
@@ -242,14 +255,23 @@ namespace API::Subsonic
         Response(Response&&) = default;
         Response& operator=(Response&&) = default;
 
-        void addNode(const std::string& key, Node node);
+        void addNode(Node::Key key, Node node);
-        Node& createNode(const std::string& key);
+        Node& createNode(Node::Key key);
-        Node& createArrayNode(const std::string& key);
+        Node& createArrayNode(Node::Key key);
 
         void write(std::ostream& os, ResponseFormat format);
 
     private:
         static Response createResponseCommon(ProtocolVersion protocolVersion, const Error* error = nullptr);
+
+        class JsonSerializer
+        {
+            public:
+            void serializeNode(std::ostream& os, const Node& node);
+            void serializeValue(std::ostream& os, const Node::ValueType& node);
+            void serializeEscapedString(std::ostream&, std::string_view str);
+        };
+
         void writeJSON(std::ostream& os);
         void writeXML(std::ostream& os);
 

src/libs/subsonic/impl/entrypoints/AlbumSongLists.cpp

@@ -133,7 +133,7 @@ namespace API::Subsonic
                 throw NotImplementedGenericError{};
 
             Response response{ Response::createOkResponse(context.serverProtocolVersion) };
-            Response::Node& albumListNode{ response.createNode(id3 ? "albumList2" : "albumList") };
+            Response::Node& albumListNode{ response.createNode(id3 ? Response::Node::Key{ "albumList2" } : Response::Node::Key{ "albumList" }) };
 
             for (const ReleaseId releaseId : releases.results)
             {
@@ -153,7 +153,7 @@ namespace API::Subsonic
                 throw UserNotAuthorizedError{};
 
             Response response{ Response::createOkResponse(context.serverProtocolVersion) };
-            Response::Node& starredNode{ response.createNode(id3 ? "starred2" : "starred") };
+            Response::Node& starredNode{ response.createNode(id3 ? Response::Node::Key{ "starred2" } : Response::Node::Key{ "starred" }) };
 
             Scrobbling::IScrobblingService& scrobbling{ *Service<Scrobbling::IScrobblingService>::get() };
 

src/libs/subsonic/impl/entrypoints/Browsing.cpp

@@ -54,7 +54,7 @@ namespace API::Subsonic
             std::size_t count{ getParameterAs<std::size_t>(context.parameters, "count").value_or(20) };
 
             Response response{ Response::createOkResponse(context.serverProtocolVersion) };
-            Response::Node& artistInfoNode{ response.createNode(id3 ? "artistInfo2" : "artistInfo") };
+            Response::Node& artistInfoNode{ response.createNode(id3 ? Response::Node::Key{ "artistInfo2" } : Response::Node::Key{ "artistInfo" }) };
 
             {
                 auto transaction{ context.dbSession.createSharedTransaction() };
@@ -236,7 +236,7 @@ namespace API::Subsonic
                 throw UserNotAuthorizedError{};
 
             Response response{ Response::createOkResponse(context.serverProtocolVersion) };
-            Response::Node& similarSongsNode{ response.createNode(id3 ? "similarSongs2" : "similarSongs") };
+            Response::Node& similarSongsNode{ response.createNode(id3 ? Response::Node::Key{ "similarSongs2" } : Response::Node::Key{ "similarSongs" }) };
             for (const TrackId trackId : tracks)
             {
                 const Track::pointer track{ Track::find(context.dbSession, trackId) };

src/libs/subsonic/impl/entrypoints/MediaLibraryScanning.cpp

@@ -28,8 +28,7 @@ namespace API::Subsonic::Scan
 
     namespace
     {
-        Response::Node
+        Response::Node createStatusResponseNode()
-            createStatusResponseNode()
         {
             Response::Node statusResponse;
 

src/libs/subsonic/impl/responses/Album.cpp

@@ -114,7 +114,7 @@ namespace API::Subsonic
 
             if (artists.size() == 1)
             {
-                albumNode.setAttribute(id3 ? "artistId" : "parent", idToString(artists.front()->getId()));
+                albumNode.setAttribute(id3 ? Response::Node::Key{ "artistId" } : Response::Node::Key{ "parent" }, idToString(artists.front()->getId()));
             }
             else
             {
@@ -140,7 +140,7 @@ namespace API::Subsonic
 
         {
             const Wt::WDateTime dateTime{ Service<Scrobbling::IScrobblingService>::get()->getLastListenDateTime(user->getId(), release->getId()) };
-            albumNode.setAttribute("played", dateTime.isValid() ? StringUtils::toISO8601String(dateTime) : "");
+            albumNode.setAttribute("played", dateTime.isValid() ? StringUtils::toISO8601String(dateTime) : std::string{ "" });
         }
 
         {
@@ -148,7 +148,7 @@ namespace API::Subsonic
             albumNode.setAttribute("musicBrainzId", mbid ? mbid->getAsString() : "");
         }
 
-        auto addClusters{ [&](std::string_view field, std::string_view clusterTypeName)
+        auto addClusters{ [&](Response::Node::Key field, std::string_view clusterTypeName)
         {
             albumNode.createEmptyArrayValue(field);
 

src/libs/subsonic/impl/responses/Song.cpp

@@ -186,7 +186,7 @@ namespace API::Subsonic
             }
         }
 
-        auto addArtistLinks{ [&](std::string_view nodeName, TrackArtistLinkType type)
+        auto addArtistLinks{ [&](Response::Node::Key nodeName, TrackArtistLinkType type)
         {
             trackResponse.createEmptyArrayChild(nodeName);
 
@@ -209,7 +209,7 @@ namespace API::Subsonic
         if (release)
             trackResponse.setAttribute("displayAlbumArtist", release->getArtistDisplayName());
 
-        auto addClusters{ [&](std::string_view field, std::string_view clusterTypeName)
+        auto addClusters{ [&](Response::Node::Key field, std::string_view clusterTypeName)
         {
             trackResponse.createEmptyArrayValue(field);
 

src/libs/utils/impl/StreamLogger.cpp

@@ -17,18 +17,19 @@
  * along with LMS.  If not, see <http://www.gnu.org/licenses/>.
  */
 
+#include <thread>
+
 #include "utils/StreamLogger.hpp"
 
 StreamLogger::StreamLogger(std::ostream& os, EnumSet<Severity> severities)
-: _os {os}
+    : _os{ os }
-, _severities {severities}
+    , _severities{ severities }
 {
 }
 
-void
+void StreamLogger::processLog(const Log& log)
-StreamLogger::processLog(const Log& log)
 {
-	if (_severities.contains(log.getSeverity()))
+    if (_severities.contains(log.getSeverity()))
-		_os << "[" << getSeverityName(log.getSeverity()) << "] [" << getModuleName(log.getModule()) << "] " << log.getMessage() << std::endl;
+        _os << std::this_thread::get_id() << " [" << getSeverityName(log.getSeverity()) << "] [" << getModuleName(log.getModule()) << "] " << log.getMessage() << std::endl;
 }
 

src/libs/utils/impl/String.cpp

@@ -219,7 +219,7 @@ namespace StringUtils
         return res;
     }
 
-    std::string jsEscape(const std::string& str)
+    std::string jsEscape(std::string_view str)
     {
         static const std::unordered_map<char, std::string_view> escapeMap
         {
@@ -249,6 +249,28 @@ namespace StringUtils
         return escaped;
     }
 
+    void writeJSEscapedString(std::ostream& os, std::string_view str)
+    {
+        static constexpr std::pair<char, std::string_view> charsToEscape[]
+        {
+            {'\\', "\\\\" },
+            { '\n', "\\n" },
+            { '\r', "\\r" },
+            { '\t', "\\t" },
+            { '"', "\\\"" },
+            { '\'', "\\\'" },
+        };
+
+        for (const char c : str)
+        {
+            auto itEntry{ std::find_if(std::cbegin(charsToEscape), std::cend(charsToEscape), [=](const auto& entry) { return entry.first == c;}) };
+            if (itEntry != std::cend(charsToEscape))
+                os << itEntry->second;
+            else
+                os << c;
+        }
+    }
+
     std::string escapeString(std::string_view str, std::string_view charsToEscape, char escapeChar)
     {
         std::string res;

src/libs/utils/impl/WtLogger.cpp

@@ -19,14 +19,25 @@
 
 #include "utils/WtLogger.hpp"
 
+#include <thread>
+#include <sstream>
 #include <Wt/WApplication.h>
 #include <Wt/WLogger.h>
 
 #include "utils/Logger.hpp"
 
-void
+namespace
-WtLogger::processLog(const Log& log)
 {
-	Wt::log(getSeverityName(log.getSeverity())) << Wt::WLogger::sep << "[" << getModuleName(log.getModule()) << "]" << Wt::WLogger::sep << log.getMessage();
+    std::string to_string(std::thread::id id)
+    {
+        std::ostringstream oss;
+        oss << id;
+        return oss.str();
+    }
+}
+
+void WtLogger::processLog(const Log& log)
+{
+    Wt::log(getSeverityName(log.getSeverity())) << Wt::WLogger::sep << to_string(std::this_thread::get_id()) << Wt::WLogger::sep << "[" << getModuleName(log.getModule()) << "]" << Wt::WLogger::sep << log.getMessage();
 }
 

src/libs/utils/include/utils/Logger.hpp

@@ -26,33 +26,33 @@
 
 enum class Severity
 {
-	FATAL,
+    FATAL,
-	ERROR,
+    ERROR,
-	WARNING,
+    WARNING,
-	INFO,
+    INFO,
-	DEBUG,
+    DEBUG,
 };
 
 enum class Module
 {
-	API_SUBSONIC,
+    API_SUBSONIC,
-	AUTH,
+    AUTH,
-	AV,
+    AV,
-	CHILDPROCESS,
+    CHILDPROCESS,
-	COVER,
+    COVER,
-	DB,
+    DB,
-	DBUPDATER,
+    DBUPDATER,
-	FEATURE,
+    FEATURE,
-	HTTP,
+    HTTP,
-	MAIN,
+    MAIN,
-	METADATA,
+    METADATA,
-	REMOTE,
+    REMOTE,
-	SCROBBLING,
+    SCROBBLING,
-	SERVICE,
+    SERVICE,
-	RECOMMENDATION,
+    RECOMMENDATION,
-	TRANSCODE,
+    TRANSCODE,
-	UI,
+    UI,
-	UTILS,
+    UTILS,
 };
 
 const char* getModuleName(Module mod);
@@ -61,30 +61,32 @@ const char* getSeverityName(Severity sev);
 class Logger;
 class Log
 {
-	public:
+public:
-		Log(Logger* logger, Module module, Severity severity);
+    Log(Logger* logger, Module module, Severity severity);
-		~Log();
+    ~Log();
 
-		Module getModule() const { return _module; }
+    Module getModule() const { return _module; }
-		Severity getSeverity() const { return _severity; }
+    Severity getSeverity() const { return _severity; }
-		std::string getMessage() const;
+    std::string getMessage() const;
 
-		std::ostringstream& getOstream() { return _oss; }
+    std::ostringstream& getOstream() { return _oss; }
 
-	private:
+private:
-		Module _module;
+    Log(const Log&) = delete;
-		Severity _severity;
+    Log& operator=(const Log&) = delete;
-		std::ostringstream _oss;
+
-		Logger* _logger {};
+    Module _module;
+    Severity _severity;
+    std::ostringstream _oss;
+    Logger* _logger{};
 };
 
 class Logger
 {
-	public:
+public:
-		virtual ~Logger() = default;
+    virtual ~Logger() = default;
-		virtual void processLog(const Log& log) = 0;
+    virtual void processLog(const Log& log) = 0;
 };
 
-#define LMS_LOG(module, severity)		Log(Service<Logger>::get(), Module::module, Severity::severity).getOstream()
+#define LMS_LOG(module, severity)		Log{Service<Logger>::get(), Module::module, Severity::severity}.getOstream()
-#define LMS_LOG_EX(module, severity)	Log(Service<Logger>::get(), module, severity).getOstream()
+#define LMS_LOG_EX(module, severity)	Log{Service<Logger>::get(), module, severity}.getOstream()
-

src/libs/utils/include/utils/String.hpp

@@ -83,7 +83,8 @@ namespace StringUtils {
 
     [[nodiscard]] std::string replaceInString(std::string_view str, const std::string& from, const std::string& to);
 
-    [[nodiscard]] std::string jsEscape(const std::string& str);
+    [[nodiscard]] std::string jsEscape(std::string_view str);
+    void writeJSEscapedString(std::ostream& os, std::string_view str);
 
     [[nodiscard]] std::string escapeString(std::string_view str, std::string_view charsToEscape, char escapeChar);