qbs-config: Understand JavaScript for all types.

The current code understands JS maps, but not lists of maps etc, which
is certainly unexpected. So allow JS literals for all types.
Additionally, simple sequences of characters are still interpreted as
strings, so users are not forced to quote in the common case.

Change-Id: Ifd345b86cd730fb1d394dbf90e9357fed86edd97
Reviewed-by: Joerg Bornemann <joerg.bornemann@digia.com>

2 files changed, 26 insertions, 41 deletions

diff --git a/src/app/shared/qbssettings.cpp b/src/app/shared/qbssettings.cpp
index bbb81f28e..9bb3fe032 100644
--- a/src/app/shared/qbssettings.cpp
+++ b/src/app/shared/qbssettings.cpp
@@ -36,53 +36,28 @@
 
 using qbs::toJSLiteral;
 
-static QString mapToString(const QVariantMap &vm)
-{
-    QString str = QLatin1String("{");
-    for (QVariantMap::const_iterator it = vm.begin(); it != vm.end(); ++it) {
-        if (it != vm.begin())
-            str += QLatin1Char(',');
-        if (it.value().type() == QVariant::Map) {
-            str += toJSLiteral(it.key()) + QLatin1Char(':');
-            str += mapToString(it.value().toMap());
-        } else {
-            str += toJSLiteral(it.key()) + QLatin1Char(':') + toJSLiteral(it.value());
-        }
-    }
-    str += QLatin1Char('}');
-    return str;
-}
-
 QString settingsValueToRepresentation(const QVariant &value)
 {
-    if (value.type() == QVariant::Bool)
-        return QLatin1String(value.toBool() ? "true" : "false");
-    if (value.type() == QVariant::Map)
-        return mapToString(value.toMap());
-    return value.toStringList().join(QLatin1String(","));
+    return toJSLiteral(value);
 }
 
-static QVariantMap mapFromString(const QString &str)
+static QVariant variantFromString(const QString &str)
 {
     // ### use Qt5's JSON reader at some point.
     QScriptEngine engine;
     QScriptValue sv = engine.evaluate(QLatin1String("(function(){return ")
                                       + str + QLatin1String(";})()"));
     if (sv.isError())
-        return QVariantMap();
-    return sv.toVariant().toMap();
+        return QVariant();
+    return sv.toVariant();
 }
 
 QVariant representationToSettingsValue(const QString &representation)
 {
-    if (representation == QLatin1String("true"))
-        return QVariant(true);
-    if (representation == QLatin1String("false"))
-        return QVariant(false);
-    if (representation.startsWith(QLatin1Char('{')))
-        return mapFromString(representation);
-    const QStringList list = representation.split(QLatin1Char(','), QString::SkipEmptyParts);
-    if (list.count() > 1)
-        return list;
+    const QVariant variant = variantFromString(representation);
+    if (variant.isValid())
+        return variant;
+
+    // If it's not valid JavaScript, interpret the value as a string.
     return representation;
 }
diff --git a/src/lib/corelib/tools/scripttools.cpp b/src/lib/corelib/tools/scripttools.cpp
index e0364df33..3ebca42a9 100644
--- a/src/lib/corelib/tools/scripttools.cpp
+++ b/src/lib/corelib/tools/scripttools.cpp
@@ -85,9 +85,9 @@ QString toJSLiteral(const QStringList &strs)
 
 QString toJSLiteral(const QVariant &val)
 {
-    if (!val.isValid()) {
+    if (!val.isValid())
         return QLatin1String("undefined");
-    } else if (val.type() == QVariant::List || val.type() == QVariant::StringList) {
+    if (val.type() == QVariant::List || val.type() == QVariant::StringList) {
         QString res;
         foreach (const QVariant &child, val.toList()) {
             if (res.length()) res.append(QLatin1String(", "));
@@ -96,13 +96,23 @@ QString toJSLiteral(const QVariant &val)
         res.prepend(QLatin1Char('['));
         res.append(QLatin1Char(']'));
         return res;
-    } else if (val.type() == QVariant::Bool) {
+    }
+    if (val.type() == QVariant::Map) {
+        const QVariantMap &vm = val.toMap();
+        QString str = QLatin1String("{");
+        for (QVariantMap::const_iterator it = vm.begin(); it != vm.end(); ++it) {
+            if (it != vm.begin())
+                str += QLatin1Char(',');
+            str += toJSLiteral(it.key()) + QLatin1Char(':') + toJSLiteral(it.value());
+        }
+        str += QLatin1Char('}');
+        return str;
+    }
+    if (val.type() == QVariant::Bool)
         return val.toBool() ? QLatin1String("true") : QLatin1String("false");
-    } else if (val.canConvert(QVariant::String)) {
+    if (val.canConvert(QVariant::String))
         return QLatin1Char('"') + val.toString() + QLatin1Char('"');
-    } else {
-        return QString::fromLatin1("Unconvertible type %1").arg(QLatin1String(val.typeName()));
-    }
+    return QString::fromLatin1("Unconvertible type %1").arg(QLatin1String(val.typeName()));
 }
 
 namespace Internal {