Better export in json.

4 files changed, 89 insertions, 14 deletions

diff --git a/diceparser.cpp b/diceparser.cpp
index 1113013..44a725a 100644
--- a/diceparser.cpp
+++ b/diceparser.cpp
@@ -352,7 +352,7 @@ QString DiceParser::humanReadableWarning() const
     return str;
 }
 
-QString DiceParser::resultAsJSon() const
+QString DiceParser::resultAsJSon(std::function<QString(const QString&, const QString&, bool)> colorize) const
 {
     QJsonObject obj;
     QJsonArray instructions;
@@ -362,7 +362,7 @@ QString DiceParser::resultAsJSon() const
 
         m_parsingToolbox->addResultInJson(inst, Dice::RESULT_TYPE::SCALAR, "scalar", start, true);
         m_parsingToolbox->addResultInJson(inst, Dice::RESULT_TYPE::STRING, "string", start, false);
-        m_parsingToolbox->addDiceResultInJson(inst, start);
+        m_parsingToolbox->addDiceResultInJson(inst, start, colorize);
 
         instructions.append(inst);
     }
diff --git a/include/diceparser.h b/include/diceparser.h
index 4d5555e..56dcb7d 100644
--- a/include/diceparser.h
+++ b/include/diceparser.h
@@ -105,7 +105,7 @@ public:
     QString comment() const;
     QString humanReadableWarning() const;
     QString humanReadableError() const;
-    QString resultAsJSon() const;
+    QString resultAsJSon(std::function<QString(const QString&, const QString&, bool)> colorize) const;
 
     //    QStringList stringResult() const;
     //    QStringList allDiceResult(bool& hasAlias) const;
diff --git a/include/parsingtoolbox.h b/include/parsingtoolbox.h
index d0a757f..f9c7484 100644
--- a/include/parsingtoolbox.h
+++ b/include/parsingtoolbox.h
@@ -231,8 +231,9 @@ public:
     static SubtituteInfo readPlaceHolderFromString(const QString& source, int& start);
     static ExportedDiceResult finalDiceResultFromInstruction(ExecutionNode* start);
     static ExportedDiceResult allDiceResultFromInstruction(ExecutionNode* start);
-    void addResultInJson(QJsonObject obj, Dice::RESULT_TYPE type, const QString& key, ExecutionNode* start, bool b);
-    void addDiceResultInJson(QJsonObject obj, ExecutionNode* start);
+    void addResultInJson(QJsonObject& obj, Dice::RESULT_TYPE type, const QString& key, ExecutionNode* start, bool b);
+    void addDiceResultInJson(QJsonObject& obj, ExecutionNode* start,
+                             std::function<QString(const QString&, const QString&, bool)> colorize);
 
     // accessors
     void setComment(const QString& comment);
@@ -249,6 +250,7 @@ public:
     void cleanUpAliases();
 
     static bool readStringResultParameter(QString& str);
+    static QString replacePlaceHolderFromJson(const QString& source, const QJsonObject& obj);
 
 private:
     QMap<QString, BooleanCondition::LogicOperator> m_logicOp;
diff --git a/parsingtoolbox.cpp b/parsingtoolbox.cpp
index b357716..af89aaf 100644
--- a/parsingtoolbox.cpp
+++ b/parsingtoolbox.cpp
@@ -725,11 +725,6 @@ QString ParsingToolBox::finalStringResult() const
     stringResult= ParsingToolBox::replaceVariableToValue(stringResult, allStringlist, errorMap);
     stringResult= ParsingToolBox::replacePlaceHolderToValue(stringResult, listFull);
 
-    /*bool isInt= true;
-    stringResult.toInt(&isInt);
-    if(!isInt)
-        resultStr= stringResult;*/
-
     return stringResult;
 }
 
@@ -1158,6 +1153,82 @@ QString ParsingToolBox::replaceVariableToValue(const QString& source, QStringLis
     return result;
 }
 
+QString ParsingToolBox::replacePlaceHolderFromJson(const QString& source, const QJsonObject& obj)
+{
+    QStringList resultList;
+    auto instructions= obj["instructions"].toArray();
+    std::vector<std::vector<std::pair<int, QList<QStringList>>>> instructionResult;
+    for(auto inst : instructions)
+    {
+        std::vector<std::pair<int, QList<QStringList>>> map;
+        auto obj= inst.toObject();
+        auto vals= obj["diceval"].toArray();
+        int lastFace= -1;
+        for(auto valRef : vals)
+        {
+            auto diceObj= valRef.toObject();
+            auto face= diceObj["face"].toInt();
+            auto it= std::find_if(std::begin(map), std::end(map),
+                                  [face](const std::pair<int, QList<QStringList>>& val) { return val.first == face; });
+
+            auto realVal= diceObj["string"].toString();
+            if(lastFace == -1 || lastFace != face)
+            {
+                QList<QStringList> listOfList;
+                listOfList << (QStringList() << realVal);
+                map.push_back({face, listOfList});
+            }
+            else if(lastFace == face)
+            {
+                auto& valList= it->second.last();
+                valList.append(realVal);
+            }
+            lastFace= face;
+        }
+        instructionResult.push_back(map);
+    }
+    std::transform(std::begin(instructionResult), std::end(instructionResult), std::back_inserter(resultList),
+                   [](const std::vector<std::pair<int, QList<QStringList>>>& map) {
+                       QStringList valuesStr;
+                       auto multiKey= (map.size() > 1);
+                       for(auto item : map)
+                       {
+                           auto face= item.first;
+                           auto valueList= item.second;
+                           QStringList strs;
+                           for(auto list : valueList)
+                           {
+                               strs << list.join(",");
+                           }
+                           if(!multiKey)
+                               valuesStr << strs.join(",");
+                           else
+                               valuesStr << QString("d%1:(%2)").arg(face).arg(strs.join(","));
+                       }
+                       return valuesStr.join(" - ");
+                   });
+
+    QString result= source;
+    int start= source.size() - 1;
+    bool valid= true;
+    do
+    {
+        auto ref= readPlaceHolderFromString(source, start);
+        if(ref.isValid())
+        {
+            result.remove(ref.position(), ref.length());
+            auto val= resultList[ref.resultIndex() - 1];
+            result.insert(ref.position(), val);
+        }
+        else
+        {
+            valid= false;
+        }
+    } while(valid);
+
+    return result;
+}
+
 QString ParsingToolBox::replacePlaceHolderToValue(const QString& source, const QList<ExportedDiceResult>& list)
 {
     QStringList resultList;
@@ -2337,15 +2408,17 @@ ExportedDiceResult ParsingToolBox::allDiceResultFromInstruction(ExecutionNode* s
     return nodeResult;
 }
 
-void ParsingToolBox::addResultInJson(QJsonObject obj, Dice::RESULT_TYPE type, const QString& key, ExecutionNode* start,
+void ParsingToolBox::addResultInJson(QJsonObject& obj, Dice::RESULT_TYPE type, const QString& key, ExecutionNode* start,
                                      bool b)
 {
     auto pair= hasResultOfType(type, start, b);
     if(pair.first)
-        obj[key]= pair.second.toReal();
+        obj[key]= QJsonValue::fromVariant(pair.second);
 }
 
-void ParsingToolBox::addDiceResultInJson(QJsonObject obj, ExecutionNode* start)
+void ParsingToolBox::addDiceResultInJson(
+    QJsonObject& obj, ExecutionNode* start,
+    std::function<QString(const QString& value, const QString& color, bool highlighted)> colorize)
 {
     QJsonArray diceValues;
     auto result= ParsingToolBox::allDiceResultFromInstruction(start);
@@ -2359,7 +2432,7 @@ void ParsingToolBox::addDiceResultInJson(QJsonObject obj, ExecutionNode* start)
                 diceObj["face"]= static_cast<qreal>(hlDice.faces());
                 diceObj["color"]= hlDice.color();
                 diceObj["displayed"]= hlDice.displayed();
-                diceObj["string"]= hlDice.getResultString();
+                diceObj["string"]= colorize(hlDice.getResultString(), hlDice.color(), hlDice.isHighlighted());
                 diceObj["highlight"]= hlDice.isHighlighted();
                 diceObj["uuid"]= hlDice.uuid();
                 auto val= hlDice.result();