New Api for string result subclass dice result.

10 files changed, 156 insertions, 78 deletions

diff --git a/node/helpnode.cpp b/node/helpnode.cpp
index 7748012..af1b2fd 100644
--- a/node/helpnode.cpp
+++ b/node/helpnode.cpp
@@ -31,7 +31,7 @@ void HelpNode::run(ExecutionNode* previous)
 
     if((nullptr == previous) && (txtResult != nullptr))
     {
-        txtResult->setText(QObject::tr("Rolisteam Dice Parser:\n"
+        txtResult->addText(QObject::tr("Rolisteam Dice Parser:\n"
                                        "\n"
                                        "Example (with ! as prefix):\n"
                                        "!2d6\n"
@@ -100,9 +100,10 @@ void HelpNode::run(ExecutionNode* previous)
     }
     else if(nullptr != previous)
     {
-        txtResult->setText(previous->getHelp());
+        txtResult->addText(previous->getHelp());
         m_result->setPrevious(previous->getResult());
     }
+    txtResult->finished();
 
     if(nullptr != m_nextNode)
     {
diff --git a/node/listaliasnode.cpp b/node/listaliasnode.cpp
index 7aa1c32..bc930da 100644
--- a/node/listaliasnode.cpp
+++ b/node/listaliasnode.cpp
@@ -30,7 +30,8 @@ void ListAliasNode::run(ExecutionNode* previous)
     StringResult* txtResult= dynamic_cast<StringResult*>(m_result);
     txtResult->setHighLight(false);
 
-    txtResult->setText(buildList());
+    txtResult->addText(buildList());
+    txtResult->finished();
     if(nullptr != previous)
     {
         // txtResult->setText(previous->getHelp());
diff --git a/node/listsetrollnode.cpp b/node/listsetrollnode.cpp
index 565a609..5caae34 100644
--- a/node/listsetrollnode.cpp
+++ b/node/listsetrollnode.cpp
@@ -21,6 +21,8 @@
 #include "listsetrollnode.h"
 #include "die.h"
 
+#include <QDebug>
+
 ListSetRollNode::ListSetRollNode() : m_diceResult(new DiceResult()), m_stringResult(new StringResult()), m_unique(false)
 {
     m_result= m_stringResult;
@@ -71,16 +73,20 @@ void ListSetRollNode::run(ExecutionNode* previous)
             else
             {
                 m_result->setPrevious(result);
-                QStringList rollResult;
                 for(quint64 i= 0; i < diceCount; ++i)
                 {
+                    QStringList rollResult;
                     Die* die= new Die();
                     computeFacesNumber(die);
                     die->roll();
                     m_diceResult->insertResult(die);
                     getValueFromDie(die, rollResult);
+                    for(auto str : rollResult)
+                    {
+                        m_stringResult->addText(str);
+                    }
                 }
-                m_stringResult->setText(rollResult.join(","));
+                m_stringResult->finished();
             }
             if(nullptr != m_nextNode)
             {
diff --git a/node/occurencecountnode.cpp b/node/occurencecountnode.cpp
index f82fa35..5140d19 100644
--- a/node/occurencecountnode.cpp
+++ b/node/occurencecountnode.cpp
@@ -148,7 +148,8 @@ void OccurenceCountNode::runForStringResult(const std::map<qint64, qint64>& mapO
     else
         result= QObject::tr("No matching result");
 
-    m_stringResult->setText(QStringLiteral("%1 - [%2]").arg(result).arg(resultList.join(',')));
+    m_stringResult->addText(QStringLiteral("%1 - [%2]").arg(result).arg(resultList.join(',')));
+    m_stringResult->finished();
 }
 void OccurenceCountNode::runForDiceResult(const std::map<qint64, qint64>& mapOccurence)
 {
diff --git a/node/repeaternode.cpp b/node/repeaternode.cpp
index 26fab8f..e5e5c81 100644
--- a/node/repeaternode.cpp
+++ b/node/repeaternode.cpp
@@ -101,7 +101,8 @@ void RepeaterNode::run(ExecutionNode* previousNode)
                 list.append(QStringLiteral("%1 - Details [%2]").arg(value).arg(diceStr.join(",")));
             }
         });
-        string->setText(list.join('\n'));
+        string->addText(list.join('\n'));
+        string->finished();
         m_result= string;
     }
 
diff --git a/node/stringnode.cpp b/node/stringnode.cpp
index 78b270a..e908463 100644
--- a/node/stringnode.cpp
+++ b/node/stringnode.cpp
@@ -21,7 +21,8 @@ void StringNode::run(ExecutionNode* previous)
 void StringNode::setString(QString str)
 {
     m_data= str;
-    m_stringResult->setText(m_data);
+    m_stringResult->addText(m_data);
+    m_stringResult->finished();
 }
 QString StringNode::toString(bool withLabel) const
 {
diff --git a/result/diceresult.h b/result/diceresult.h
index 8f30340..0ee622c 100644
--- a/result/diceresult.h
+++ b/result/diceresult.h
@@ -39,58 +39,58 @@ public:
     /**
      * @brief ~DiceResult
      */
-    virtual ~DiceResult();
+    virtual ~DiceResult() override;
 
     /**
      * @brief getResultList
      * @return
      */
-    QList<Die*>& getResultList();
+    virtual QList<Die*>& getResultList();
     /**
      * @brief insertResult
      */
-    void insertResult(Die*);
+    virtual void insertResult(Die*);
 
     /**
      * @brief setResultList
      * @param list
      */
-    void setResultList(QList<Die*> list);
+    virtual void setResultList(QList<Die*> list);
 
     /**
      * @brief getScalar
      * @return
      */
-    virtual QVariant getResult(Dice::RESULT_TYPE);
+    virtual QVariant getResult(Dice::RESULT_TYPE) override;
     /**
      * @brief toString
      * @return
      */
-    virtual QString toString(bool wl);
+    virtual QString toString(bool wl) override;
     /**
      * @brief isHomogeneous
      */
-    bool isHomogeneous() const;
+    virtual bool isHomogeneous() const;
     /**
      * @brief setHomogeneous
      */
-    void setHomogeneous(bool);
+    virtual void setHomogeneous(bool);
 
     Die::ArithmeticOperator getOperator() const;
     void setOperator(const Die::ArithmeticOperator& dieOperator);
     bool contains(Die* die, const std::function<bool(const Die*, const Die*)> equal);
 
-    void clear();
+    void clear() override;
 
-    virtual Result* getCopy() const;
+    virtual Result* getCopy() const override;
 
-private:
+protected:
     qreal getScalarResult();
 
-private:
+protected:
     QList<Die*> m_diceValues;
     bool m_homogeneous;
-    Die::ArithmeticOperator m_operator;
+    Die::ArithmeticOperator m_operator= Die::ArithmeticOperator::PLUS;
 };
 Q_DECLARE_METATYPE(QList<Die*>)
 #endif // DICERESULT_H
diff --git a/result/stringresult.cpp b/result/stringresult.cpp
index b5c490c..201d1f3 100644
--- a/result/stringresult.cpp
+++ b/result/stringresult.cpp
@@ -1,33 +1,39 @@
 #include "stringresult.h"
+#include <QDebug>
 
 StringResult::StringResult()
 {
     m_highlight= true;
     m_resultTypes= static_cast<int>(Dice::RESULT_TYPE::STRING);
 }
-void StringResult::setText(QString text)
+void StringResult::addText(QString text)
 {
-    m_value= text;
+    m_value.append(text);
 }
 StringResult::~StringResult() {}
 bool StringResult::hasResultOfType(Dice::RESULT_TYPE resultType) const
 {
+    bool val= false;
 
-    if(resultType == Dice::RESULT_TYPE::STRING)
+    switch(resultType)
     {
-        return true;
-    }
-    else if(resultType == Dice::RESULT_TYPE::SCALAR)
-    {
-        bool ok= false;
-        getText().toInt(&ok);
-        return ok;
+    case Dice::RESULT_TYPE::STRING:
+        val= !isDigitOnly();
+        break;
+    case Dice::RESULT_TYPE::SCALAR:
+        val= isDigitOnly();
+        break;
+    case Dice::RESULT_TYPE::DICE_LIST:
+        val= (isDigitOnly() && m_value.size() > 1);
+        break;
+    default:
+        break;
     }
-    return false;
+    return val;
 }
 QString StringResult::getText() const
 {
-    return m_value;
+    return m_value.join(",");
 }
 QVariant StringResult::getResult(Dice::RESULT_TYPE type)
 {
@@ -36,7 +42,7 @@ QVariant StringResult::getResult(Dice::RESULT_TYPE type)
     case Dice::RESULT_TYPE::STRING:
         return getText();
     case Dice::RESULT_TYPE::SCALAR:
-        return getText().toInt();
+        return getScalarResult();
     default:
         return QVariant();
     }
@@ -61,11 +67,39 @@ bool StringResult::hasHighLight() const
 {
     return m_highlight;
 }
+
+void StringResult::finished()
+{
+    if(isDigitOnly())
+    {
+        std::for_each(m_value.begin(), m_value.end(), [this](const QString& str) {
+            auto die= new Die();
+            die->setMaxValue(m_stringCount);
+            die->setValue(str.toInt());
+            insertResult(die);
+        });
+    }
+}
+
+void StringResult::setStringCount(int count)
+{
+    m_stringCount= count;
+}
+
+bool StringResult::isDigitOnly() const
+{
+    return std::all_of(m_value.begin(), m_value.end(), [](const QString& str) {
+        bool ok= false;
+        str.toInt(&ok);
+        return ok;
+    });
+}
+
 Result* StringResult::getCopy() const
 {
     auto copy= new StringResult();
     copy->setPrevious(getPrevious());
     copy->setHighLight(m_highlight);
-    copy->setText(m_value);
+    std::for_each(m_value.begin(), m_value.end(), [copy](const QString& str) { copy->addText(str); });
     return copy;
 }
diff --git a/result/stringresult.h b/result/stringresult.h
index 0e469fe..f1029c7 100644
--- a/result/stringresult.h
+++ b/result/stringresult.h
@@ -1,12 +1,13 @@
 #ifndef STRINGRESULT_H
 #define STRINGRESULT_H
 
-#include "result.h"
+#include "diceresult.h"
 #include <QString>
 /**
  * @brief The StringResult class stores command result for String.
  */
-class StringResult : public Result
+
+class StringResult : public DiceResult
 {
 public:
     /**
@@ -16,36 +17,26 @@ public:
     /**
      * @brief StringResult
      */
-    virtual ~StringResult();
-    /**
-     * @brief setText
-     * @param text
-     */
-    void setText(QString text);
-    /**
-     * @brief getText
-     * @return
-     */
+    virtual ~StringResult() override;
+    void addText(QString text);
+    void finished();
     QString getText() const;
-    /**
-     * @brief getScalar
-     * @return
-     */
-    virtual QVariant getResult(Dice::RESULT_TYPE);
-    /**
-     * @brief toString
-     * @return
-     */
+    virtual QVariant getResult(Dice::RESULT_TYPE) override;
     virtual QString toString(bool);
 
     virtual void setHighLight(bool);
     virtual bool hasHighLight() const;
-    virtual bool hasResultOfType(Dice::RESULT_TYPE resultType) const;
-    virtual Result* getCopy() const;
+    virtual bool hasResultOfType(Dice::RESULT_TYPE resultType) const override;
+    virtual Result* getCopy() const override;
+
+    bool isDigitOnly() const;
+
+    void setStringCount(int count);
 
 private:
-    QString m_value;
+    QStringList m_value;
     bool m_highlight;
+    int m_stringCount= 0;
 };
 
 #endif // STRINGRESULT_H
diff --git a/tests/dice/tst_dice.cpp b/tests/dice/tst_dice.cpp
index 8eed852..7675615 100644
--- a/tests/dice/tst_dice.cpp
+++ b/tests/dice/tst_dice.cpp
@@ -120,6 +120,9 @@ private slots:
     void commandsTest();
     void commandsTest_data();
 
+    void rangedCommandsTest();
+    void rangedCommandsTest_data();
+
     void dangerousCommandsTest();
     void dangerousCommandsTest_data();
 
@@ -242,7 +245,7 @@ void TestDice::validatorListTest_data()
     QTest::addColumn<QString>("cmd");
     QTest::addColumn<int>("result");
 
-    QTest::addRow("cmd1") << "2d[6-6]c6" << 2;
+    QTest::addRow("cmd1") << "2d[6..6]c6" << 2;
     QTest::addRow("cmd2") << "[6,2]c[:>6&%2=0]" << 2;
 }
 
@@ -341,12 +344,12 @@ void TestDice::commandsTest_data()
     QTest::addRow("cmd60") << "5-5*5+5";
     QTest::addRow("cmd61") << "((3+4)*2)d6";
     QTest::addRow("cmd62") << "4d6i[=6]{+1d6}";
-    QTest::addRow("cmd63") << "10d[-8--1]";
+    QTest::addRow("cmd63") << "10d[-8..-1]";
     QTest::addRow("cmd64") << "4d6e6i[=4]{-4}+2";
     QTest::addRow("cmd65") << "4d6e6f[!=4]+2";
     QTest::addRow("cmd66") << "5d10g10";
     QTest::addRow("cmd67") << "4d6p[4:blue]c[>=4];1d6p[1:#FFFFFF]c6-@c1;1d6p[1:#FF0000]c[>=4]+@c6-@c1";
-    QTest::addRow("cmd68") << "10d[0-9]";
+    QTest::addRow("cmd68") << "10d[0..9]";
     QTest::addRow("cmd69") << "1d8e8;1d6e6mk1+2";
     QTest::addRow("cmd70") << "3d100g50";
     QTest::addRow("cmd71") << "3d100g33";
@@ -367,6 +370,45 @@ void TestDice::commandsTest_data()
     QTest::addRow("cmd86") << "[100,200,300]k2";
     QTest::addRow("cmd87") << "100;200;300;[$1,$2,$3]k2";
     QTest::addRow("cmd88") << "1d20|3i:[>1]{\"Success\"}{\"Failure\"}";
+    QTest::addRow("cmd89") << "1L[-3,-2,2,3]+10";
+    QTest::addRow("cmd90") << "1L[-3,-2,2,3]+10;1L[-3,-2,2,3]";
+    QTest::addRow("cmd91") << "1d20|3i:[>1]{\"Success\"}{\"Failure\"}";
+}
+
+void TestDice::rangedCommandsTest()
+{
+    QFETCH(QString, cmd);
+    QFETCH(int, min);
+    QFETCH(int, max);
+
+    bool a= m_diceParser->parseLine(cmd);
+    QVERIFY2(a, "parsing");
+
+    m_diceParser->start();
+    auto results= m_diceParser->getLastIntegerResults();
+
+    QVERIFY(results.size() == 1);
+
+    auto score= results.first();
+
+    QVERIFY(score >= min);
+    QVERIFY(score <= max);
+
+    QVERIFY2(m_diceParser->humanReadableError().isEmpty(), "no error");
+    QVERIFY2(m_diceParser->humanReadableError().isEmpty(), "no error");
+
+    QVERIFY2(m_diceParser->humanReadableError().isEmpty(), "no error");
+    QVERIFY2(m_diceParser->humanReadableWarning().isEmpty(), "no warning");
+}
+
+void TestDice::rangedCommandsTest_data()
+{
+    QTest::addColumn<QString>("cmd");
+    QTest::addColumn<int>("min");
+    QTest::addColumn<int>("max");
+
+    QTest::addRow("cmd1") << "1L[5,6,7,8]+10" << 15 << 18;
+    QTest::addRow("cmd2") << "2L[5,6,7,8]+10" << 20 << 26;
 }
 
 void TestDice::wrongCommandsTest()
@@ -442,18 +484,18 @@ void TestDice::scopeDF_data()
     QTest::addColumn<int>("max");
     QTest::addColumn<bool>("valid");
 
-    QTest::newRow("test1") << "1D[-1-1]" << -1 << 1 << true;
-    QTest::newRow("test2") << "1D[-10--5]" << -10 << -5 << true;
-    QTest::newRow("test3") << "1D[-100-100]" << -100 << 100 << true;
-    QTest::newRow("test4") << "1D[-1-0]" << -1 << 0 << true;
-    QTest::newRow("test5") << "1D[10-20]" << 10 << 20 << true;
-    QTest::newRow("test6") << "1D[30-100]" << 30 << 100 << true;
-    QTest::newRow("test7") << "1D[0-99]" << 0 << 99 << true;
+    QTest::newRow("test1") << "1D[-1..1]" << -1 << 1 << true;
+    QTest::newRow("test2") << "1D[-10..-5]" << -10 << -5 << true;
+    QTest::newRow("test3") << "1D[-100..100]" << -100 << 100 << true;
+    QTest::newRow("test4") << "1D[-1..0]" << -1 << 0 << true;
+    QTest::newRow("test5") << "1D[10..20]" << 10 << 20 << true;
+    QTest::newRow("test6") << "1D[30..100]" << 30 << 100 << true;
+    QTest::newRow("test7") << "1D[0..99]" << 0 << 99 << true;
     QTest::newRow("test8") << "5-5*5+5" << -15 << -15 << true;
     QTest::newRow("test9") << "2d20c[<=13]+@c[<=3]" << 0 << 4 << true;
     QTest::newRow("test10") << "6d10c[>=6]-@c1" << -6 << 6 << true;
     QTest::newRow("test11") << "2d6k1+2d8k1+2d10k1" << 3 << 30 << true;
-    QTest::newRow("test12") << "1D[-2-50]" << -2 << 50 << true;
+    QTest::newRow("test12") << "1D[-2..50]" << -2 << 50 << true;
 }
 void TestDice::testAlias()
 {
@@ -473,14 +515,14 @@ void TestDice::testAlias_data()
     QTest::addColumn<QString>("cmd");
     QTest::addColumn<QString>("expected");
 
-    /* QTest::newRow("test1") << "!2"
-                            << "3d6c2";
-     QTest::newRow("test2") << "${rang}g4"
-                            << "${rang}d10k4";
-     QTest::newRow("test3") << "${rang}g4 # gerald"
-                            << "${rang}d10k4 # gerald";
-     QTest::newRow("test4") << "5C3"
-                            << "5d10e10c[>=3]";*/
+    QTest::newRow("test1") << "!2"
+                           << "3d6c2";
+    QTest::newRow("test2") << "${rang}g4"
+                           << "${rang}d10k4";
+    QTest::newRow("test3") << "${rang}g4 # gerald"
+                           << "${rang}d10k4 # gerald";
+    QTest::newRow("test4") << "5C3"
+                           << "5d10e10c[>=3]";
     QTest::newRow("test5") << "1d100i:[<101]{\"great!\"}{\"try again\"}"
                            << "1d100i:[<101]{\"great!\"}{\"try again\"}";
 }