QmlDesigner: Move CollectionEditor functions to utils

- Collection editor functions are moved to CollectionEditorUtils
  namespace
- Collection import tools functions are also moved to
  CollectionEditorUtils. Also, the former files of import tools are
  deleted since their functions are moved.

Task-number: QDS-11391
Change-Id: I1ec1b2b7568658c1637a4c267989425189f07039
Reviewed-by: Mahmoud Badri <mahmoud.badri@qt.io>

src/plugins/qmldesigner/CMakeLists.txt

@@ -839,7 +839,6 @@ extend_qtc_plugin(QmlDesigner
     collectiondetailssortfiltermodel.cpp collectiondetailssortfiltermodel.h
     collectioneditorconstants.h
     collectioneditorutils.cpp collectioneditorutils.h
-    collectionimporttools.cpp collectionimporttools.h
     collectionlistmodel.cpp collectionlistmodel.h
     collectionsourcemodel.cpp collectionsourcemodel.h
     collectionview.cpp collectionview.h

src/plugins/qmldesigner/components/collectioneditor/collectiondetails.cpp

@@ -28,7 +28,7 @@ const QMap<DataTypeWarning::Warning, QString> DataTypeWarning::dataTypeWarnings
 
 class CollectionDetails::Private
 {
-    using SourceFormat = CollectionEditor::SourceFormat;
+    using SourceFormat = CollectionEditorConstants::SourceFormat;
 
 public:
     QList<CollectionProperty> properties;
@@ -101,7 +101,7 @@ CollectionDetails::~CollectionDetails() = default;
 
 void CollectionDetails::resetDetails(const QStringList &propertyNames,
                                      const QList<QJsonObject> &elements,
-                                     CollectionEditor::SourceFormat format)
+                                     CollectionEditorConstants::SourceFormat format)
 {
     if (!isValid())
         return;
@@ -295,7 +295,7 @@ CollectionReference CollectionDetails::reference() const
     return d->reference;
 }
 
-CollectionEditor::SourceFormat CollectionDetails::sourceFormat() const
+CollectionEditorConstants::SourceFormat CollectionDetails::sourceFormat() const
 {
     return d->sourceFormat;
 }

src/plugins/qmldesigner/components/collectioneditor/collectiondetails.h

@@ -70,7 +70,7 @@ public:
 
     void resetDetails(const QStringList &propertyNames,
                       const QList<QJsonObject> &elements,
-                      CollectionEditor::SourceFormat format);
+                      CollectionEditorConstants::SourceFormat format);
     void insertColumn(const QString &propertyName,
                       int colIdx = -1,
                       const QVariant &defaultValue = {},
@@ -86,7 +86,7 @@ public:
     bool setPropertyType(int column, DataType type);
 
     CollectionReference reference() const;
-    CollectionEditor::SourceFormat sourceFormat() const;
+    CollectionEditorConstants::SourceFormat sourceFormat() const;
     QVariant data(int row, int column) const;
     QString propertyAt(int column) const;
     DataType typeAt(int column) const;

src/plugins/qmldesigner/components/collectioneditor/collectiondetailsmodel.cpp

@@ -390,7 +390,7 @@ QStringList CollectionDetailsModel::typesList()
 
 void CollectionDetailsModel::loadCollection(const ModelNode &sourceNode, const QString &collection)
 {
-    QString fileName = CollectionEditor::getSourceCollectionPath(sourceNode);
+    QString fileName = CollectionEditorUtils::getSourceCollectionPath(sourceNode);
 
     CollectionReference newReference{sourceNode, collection};
     bool alreadyOpen = m_openedCollections.contains(newReference);
@@ -405,9 +405,9 @@ void CollectionDetailsModel::loadCollection(const ModelNode &sourceNode, const Q
     } else {
         deselectAll();
         switchToCollection(newReference);
-        if (sourceNode.type() == CollectionEditor::JSONCOLLECTIONMODEL_TYPENAME)
+        if (sourceNode.type() == CollectionEditorConstants::JSONCOLLECTIONMODEL_TYPENAME)
             loadJsonCollection(fileName, collection);
-        else if (sourceNode.type() == CollectionEditor::CSVCOLLECTIONMODEL_TYPENAME)
+        else if (sourceNode.type() == CollectionEditorConstants::CSVCOLLECTIONMODEL_TYPENAME)
             loadCsvCollection(fileName, collection);
     }
 }
@@ -467,7 +467,7 @@ void CollectionDetailsModel::closeCurrentCollectionIfSaved()
 
 void CollectionDetailsModel::loadJsonCollection(const QString &source, const QString &collection)
 {
-    using CollectionEditor::SourceFormat;
+    using CollectionEditorConstants::SourceFormat;
 
     QFile sourceFile(source);
     QJsonArray collectionNodes;
@@ -512,7 +512,7 @@ void CollectionDetailsModel::loadJsonCollection(const QString &source, const QSt
 void CollectionDetailsModel::loadCsvCollection(const QString &source,
                                               [[maybe_unused]] const QString &collectionName)
 {
-    using CollectionEditor::SourceFormat;
+    using CollectionEditorConstants::SourceFormat;
 
     QFile sourceFile(source);
     QStringList headers;
@@ -601,8 +601,8 @@ bool CollectionDetailsModel::saveCollection(const QString &filePath, CollectionD
     bool saved = false;
 
     const ModelNode node = m_currentCollection.reference().node;
-    QString path = CollectionEditor::getSourceCollectionPath(node);
+    QString path = CollectionEditorUtils::getSourceCollectionPath(node);
-    QString saveFormat = CollectionEditor::getSourceCollectionType(node);
+    QString saveFormat = CollectionEditorUtils::getSourceCollectionType(node);
 
     QFile sourceFile(path);
 

src/plugins/qmldesigner/components/collectioneditor/collectiondetailssortfiltermodel.cpp

@@ -80,7 +80,9 @@ bool CollectionDetailsSortFilterModel::lessThan(const QModelIndex &sourceleft,
     if (sourceleft.column() == sourceRight.column()) {
         int column = sourceleft.column();
         CollectionDetails::DataType columnType = m_source->propertyDataType(column);
-        return CollectionEditor::variantIslessThan(sourceleft.data(), sourceRight.data(), columnType);
+        return CollectionEditorUtils::variantIslessThan(sourceleft.data(),
+                                                        sourceRight.data(),
+                                                        columnType);
     }
 
     return false;

src/plugins/qmldesigner/components/collectioneditor/collectioneditorconstants.h

@@ -3,7 +3,7 @@
 
 #pragma once
 
-namespace QmlDesigner::CollectionEditor {
+namespace QmlDesigner::CollectionEditorConstants {
 
 enum class SourceFormat { Unknown, Json, Csv };
 
@@ -17,4 +17,4 @@ inline constexpr char CSVCOLLECTIONMODEL_TYPENAME[]         = "QtQuick.Studio.Ut
 inline constexpr char JSONCOLLECTIONCHILDMODEL_TYPENAME[]   = "QtQuick.Studio.Utils.ChildListModel";
 inline constexpr char JSONBACKEND_TYPENAME[]                = "JsonData";
 
-} // namespace QmlDesigner::CollectionEditor
+} // namespace QmlDesigner::CollectionEditorConstants

src/plugins/qmldesigner/components/collectioneditor/collectioneditorutils.cpp

@@ -18,7 +18,10 @@
 
 #include <QColor>
 #include <QJsonArray>
+#include <QJsonDocument>
 #include <QJsonObject>
+#include <QJsonParseError>
+#include <QJsonValue>
 #include <QUrl>
 
 namespace {
@@ -104,32 +107,32 @@ inline Utils::FilePath qmlDirFilePath()
 
 } // namespace
 
-namespace QmlDesigner::CollectionEditor {
+namespace QmlDesigner::CollectionEditorUtils {
 
 bool variantIslessThan(const QVariant &a, const QVariant &b, CollectionDetails::DataType type)
 {
     return std::visit(LessThanVisitor{}, valueToVariant(a, type), valueToVariant(b, type));
 }
 
-SourceFormat getSourceCollectionFormat(const ModelNode &node)
+CollectionEditorConstants::SourceFormat getSourceCollectionFormat(const ModelNode &node)
 {
     using namespace QmlDesigner;
-    if (node.type() == CollectionEditor::JSONCOLLECTIONMODEL_TYPENAME)
+    if (node.type() == CollectionEditorConstants::JSONCOLLECTIONMODEL_TYPENAME)
-        return CollectionEditor::SourceFormat::Json;
+        return CollectionEditorConstants::SourceFormat::Json;
 
-    if (node.type() == CollectionEditor::CSVCOLLECTIONMODEL_TYPENAME)
+    if (node.type() == CollectionEditorConstants::CSVCOLLECTIONMODEL_TYPENAME)
-        return CollectionEditor::SourceFormat::Csv;
+        return CollectionEditorConstants::SourceFormat::Csv;
 
-    return CollectionEditor::SourceFormat::Unknown;
+    return CollectionEditorConstants::SourceFormat::Unknown;
 }
 
 QString getSourceCollectionType(const ModelNode &node)
 {
     using namespace QmlDesigner;
-    if (node.type() == CollectionEditor::JSONCOLLECTIONMODEL_TYPENAME)
+    if (node.type() == CollectionEditorConstants::JSONCOLLECTIONMODEL_TYPENAME)
         return "json";
 
-    if (node.type() == CollectionEditor::CSVCOLLECTIONMODEL_TYPENAME)
+    if (node.type() == CollectionEditorConstants::CSVCOLLECTIONMODEL_TYPENAME)
         return "csv";
 
     return {};
@@ -280,4 +283,101 @@ bool ensureDataStoreExists(bool &justCreated)
     return false;
 }
 
-} // namespace QmlDesigner::CollectionEditor
+QJsonArray loadAsSingleJsonCollection(const QUrl &url)
+{
+    QFile file(url.isLocalFile() ? url.toLocalFile() : url.toString());
+    QJsonArray collection;
+    QByteArray jsonData;
+    if (file.open(QFile::ReadOnly))
+        jsonData = file.readAll();
+
+    file.close();
+    if (jsonData.isEmpty())
+        return {};
+
+    QJsonParseError parseError;
+    QJsonDocument document = QJsonDocument::fromJson(jsonData, &parseError);
+    if (parseError.error != QJsonParseError::NoError)
+        return {};
+
+    auto refineJsonArray = [](const QJsonArray &array) -> QJsonArray {
+        QJsonArray resultArray;
+        for (const QJsonValue &collectionData : array) {
+            if (collectionData.isObject()) {
+                QJsonObject rowObject = collectionData.toObject();
+                const QStringList rowKeys = rowObject.keys();
+                for (const QString &key : rowKeys) {
+                    QJsonValue cellValue = rowObject.value(key);
+                    if (cellValue.isArray())
+                        rowObject.remove(key);
+                }
+                resultArray.push_back(rowObject);
+            }
+        }
+        return resultArray;
+    };
+
+    if (document.isArray()) {
+        collection = refineJsonArray(document.array());
+    } else if (document.isObject()) {
+        QJsonObject documentObject = document.object();
+        const QStringList mainKeys = documentObject.keys();
+
+        bool arrayFound = false;
+        for (const QString &key : mainKeys) {
+            const QJsonValue &value = documentObject.value(key);
+            if (value.isArray()) {
+                arrayFound = true;
+                collection = refineJsonArray(value.toArray());
+                break;
+            }
+        }
+
+        if (!arrayFound) {
+            QJsonObject singleObject;
+            for (const QString &key : mainKeys) {
+                const QJsonValue value = documentObject.value(key);
+
+                if (!value.isObject())
+                    singleObject.insert(key, value);
+            }
+            collection.push_back(singleObject);
+        }
+    }
+    return collection;
+}
+
+QJsonArray loadAsCsvCollection(const QUrl &url)
+{
+    QFile sourceFile(url.isLocalFile() ? url.toLocalFile() : url.toString());
+    QStringList headers;
+    QJsonArray elements;
+
+    if (sourceFile.open(QFile::ReadOnly)) {
+        QTextStream stream(&sourceFile);
+
+        if (!stream.atEnd())
+            headers = stream.readLine().split(',');
+
+        for (QString &header : headers)
+            header = header.trimmed();
+
+        if (!headers.isEmpty()) {
+            while (!stream.atEnd()) {
+                const QStringList recordDataList = stream.readLine().split(',');
+                int column = -1;
+                QJsonObject recordData;
+                for (const QString &cellData : recordDataList) {
+                    if (++column == headers.size())
+                        break;
+                    recordData.insert(headers.at(column), cellData);
+                }
+                elements.append(recordData);
+            }
+        }
+    }
+
+    return elements;
+}
+
+} // namespace QmlDesigner::CollectionEditorUtils

src/plugins/qmldesigner/components/collectioneditor/collectioneditorutils.h

@@ -14,11 +14,11 @@ namespace Utils {
 class FilePath;
 }
 
-namespace QmlDesigner::CollectionEditor {
+namespace QmlDesigner::CollectionEditorUtils {
 
 bool variantIslessThan(const QVariant &a, const QVariant &b, CollectionDetails::DataType type);
 
-SourceFormat getSourceCollectionFormat(const QmlDesigner::ModelNode &node);
+CollectionEditorConstants::SourceFormat getSourceCollectionFormat(const QmlDesigner::ModelNode &node);
 
 QString getSourceCollectionType(const QmlDesigner::ModelNode &node);
 
@@ -36,4 +36,8 @@ bool canAcceptCollectionAsModel(const ModelNode &node);
 
 QJsonArray defaultCollectionArray();
 
-} // namespace QmlDesigner::CollectionEditor
+QJsonArray loadAsSingleJsonCollection(const QUrl &url);
+
+QJsonArray loadAsCsvCollection(const QUrl &url);
+
+} // namespace QmlDesigner::CollectionEditorUtils

src/plugins/qmldesigner/components/collectioneditor/collectionimporttools.cpp

@@ -1,113 +0,0 @@
-// Copyright (C) 2023 The Qt Company Ltd.
-// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
-
-#include "collectionimporttools.h"
-
-#include <QFile>
-#include <QJsonArray>
-#include <QJsonDocument>
-#include <QJsonObject>
-#include <QJsonParseError>
-#include <QJsonValue>
-#include <QUrl>
-
-namespace QmlDesigner::CollectionEditor::ImportTools {
-
-QJsonArray loadAsSingleJsonCollection(const QUrl &url)
-{
-    QFile file(url.isLocalFile() ? url.toLocalFile() : url.toString());
-    QJsonArray collection;
-    QByteArray jsonData;
-    if (file.open(QFile::ReadOnly))
-        jsonData = file.readAll();
-
-    file.close();
-    if (jsonData.isEmpty())
-        return {};
-
-    QJsonParseError parseError;
-    QJsonDocument document = QJsonDocument::fromJson(jsonData, &parseError);
-    if (parseError.error != QJsonParseError::NoError)
-        return {};
-
-    auto refineJsonArray = [](const QJsonArray &array) -> QJsonArray {
-        QJsonArray resultArray;
-        for (const QJsonValue &collectionData : array) {
-            if (collectionData.isObject()) {
-                QJsonObject rowObject = collectionData.toObject();
-                const QStringList rowKeys = rowObject.keys();
-                for (const QString &key : rowKeys) {
-                    QJsonValue cellValue = rowObject.value(key);
-                    if (cellValue.isArray())
-                        rowObject.remove(key);
-                }
-                resultArray.push_back(rowObject);
-            }
-        }
-        return resultArray;
-    };
-
-    if (document.isArray()) {
-        collection = refineJsonArray(document.array());
-    } else if (document.isObject()) {
-        QJsonObject documentObject = document.object();
-        const QStringList mainKeys = documentObject.keys();
-
-        bool arrayFound = false;
-        for (const QString &key : mainKeys) {
-            const QJsonValue &value = documentObject.value(key);
-            if (value.isArray()) {
-                arrayFound = true;
-                collection = refineJsonArray(value.toArray());
-                break;
-            }
-        }
-
-        if (!arrayFound) {
-            QJsonObject singleObject;
-            for (const QString &key : mainKeys) {
-                const QJsonValue value = documentObject.value(key);
-
-                if (!value.isObject())
-                    singleObject.insert(key, value);
-            }
-            collection.push_back(singleObject);
-        }
-    }
-    return collection;
-}
-
-QJsonArray loadAsCsvCollection(const QUrl &url)
-{
-    QFile sourceFile(url.isLocalFile() ? url.toLocalFile() : url.toString());
-    QStringList headers;
-    QJsonArray elements;
-
-    if (sourceFile.open(QFile::ReadOnly)) {
-        QTextStream stream(&sourceFile);
-
-        if (!stream.atEnd())
-            headers = stream.readLine().split(',');
-
-        for (QString &header : headers)
-            header = header.trimmed();
-
-        if (!headers.isEmpty()) {
-            while (!stream.atEnd()) {
-                const QStringList recordDataList = stream.readLine().split(',');
-                int column = -1;
-                QJsonObject recordData;
-                for (const QString &cellData : recordDataList) {
-                    if (++column == headers.size())
-                        break;
-                    recordData.insert(headers.at(column), cellData);
-                }
-                elements.append(recordData);
-            }
-        }
-    }
-
-    return elements;
-}
-
-} // namespace QmlDesigner::CollectionEditor::ImportTools

src/plugins/qmldesigner/components/collectioneditor/collectionimporttools.h

@@ -1,18 +0,0 @@
-// Copyright (C) 2023 The Qt Company Ltd.
-// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
-
-#pragma once
-
-#include <QtCore/qtconfigmacros.h>
-
-QT_BEGIN_NAMESPACE
-class QJsonArray;
-class QUrl;
-QT_END_NAMESPACE
-
-namespace QmlDesigner::CollectionEditor::ImportTools {
-
-QJsonArray loadAsSingleJsonCollection(const QUrl &url);
-QJsonArray loadAsCsvCollection(const QUrl &url);
-
-} // namespace QmlDesigner::CollectionEditor::ImportTools

src/plugins/qmldesigner/components/collectioneditor/collectionlistmodel.cpp

@@ -29,7 +29,7 @@ namespace QmlDesigner {
 CollectionListModel::CollectionListModel(const ModelNode &sourceModel)
     : QStringListModel()
     , m_sourceNode(sourceModel)
-    , m_sourceType(CollectionEditor::getSourceCollectionType(sourceModel))
+    , m_sourceType(CollectionEditorUtils::getSourceCollectionType(sourceModel))
 {
     connect(this, &CollectionListModel::modelReset, this, &CollectionListModel::updateEmpty);
     connect(this, &CollectionListModel::rowsRemoved, this, &CollectionListModel::updateEmpty);
@@ -121,7 +121,7 @@ ModelNode CollectionListModel::sourceNode() const
 
 QString CollectionListModel::sourceAddress() const
 {
-    return CollectionEditor::getSourceCollectionPath(m_sourceNode);
+    return CollectionEditorUtils::getSourceCollectionPath(m_sourceNode);
 }
 
 bool CollectionListModel::contains(const QString &collectionName) const

src/plugins/qmldesigner/components/collectioneditor/collectionsourcemodel.cpp

@@ -25,7 +25,8 @@ QSharedPointer<QmlDesigner::CollectionListModel> loadCollection(
     const QmlDesigner::ModelNode &sourceNode,
     QSharedPointer<QmlDesigner::CollectionListModel> initialCollection = {})
 {
-    using namespace QmlDesigner::CollectionEditor;
+    using namespace QmlDesigner::CollectionEditorConstants;
+    using namespace QmlDesigner::CollectionEditorUtils;
     QString sourceFileAddress = getSourceCollectionPath(sourceNode);
 
     QSharedPointer<QmlDesigner::CollectionListModel> collectionsList;
@@ -88,9 +89,9 @@ QVariant CollectionSourceModel::data(const QModelIndex &index, int role) const
     case NodeRole:
         return QVariant::fromValue(*collectionSource);
     case CollectionTypeRole:
-        return CollectionEditor::getSourceCollectionType(*collectionSource);
+        return CollectionEditorUtils::getSourceCollectionType(*collectionSource);
     case SourceRole:
-        return collectionSource->variantProperty(CollectionEditor::SOURCEFILE_PROPERTY).value();
+        return collectionSource->variantProperty(CollectionEditorConstants::SOURCEFILE_PROPERTY).value();
     case SelectedRole:
         return index.row() == m_selectedIndex;
     case CollectionsRole:
@@ -116,7 +117,8 @@ bool CollectionSourceModel::setData(const QModelIndex &index, const QVariant &va
         collectionName.setValue(value.toString());
     } break;
     case SourceRole: {
-        auto sourceAddress = collectionSource.variantProperty(CollectionEditor::SOURCEFILE_PROPERTY);
+        auto sourceAddress = collectionSource.variantProperty(
+            CollectionEditorConstants::SOURCEFILE_PROPERTY);
         if (sourceAddress.value() == value)
             return false;
 
@@ -281,13 +283,13 @@ bool CollectionSourceModel::addCollectionToSource(const ModelNode &node,
     if (idx < 0)
         return returnError(tr("Node is not indexed in the models."));
 
-    if (node.type() != CollectionEditor::JSONCOLLECTIONMODEL_TYPENAME)
+    if (node.type() != CollectionEditorConstants::JSONCOLLECTIONMODEL_TYPENAME)
         return returnError(tr("Node should be a JSON model."));
 
     if (collectionExists(node, collectionName))
         return returnError(tr("A model with the identical name already exists."));
 
-    QString sourceFileAddress = CollectionEditor::getSourceCollectionPath(node);
+    QString sourceFileAddress = CollectionEditorUtils::getSourceCollectionPath(node);
 
     QFileInfo sourceFileInfo(sourceFileAddress);
     if (!sourceFileInfo.isFile())
@@ -424,16 +426,16 @@ void CollectionSourceModel::onCollectionNameChanged(CollectionListModel *collect
         return;
     }
 
-    if (node.type() == CollectionEditor::CSVCOLLECTIONMODEL_TYPENAME) {
+    if (node.type() == CollectionEditorConstants::CSVCOLLECTIONMODEL_TYPENAME) {
         if (!setData(nodeIndex, newName, NameRole))
             emitRenameWarning(tr("Can't rename the node"));
         return;
-    } else if (node.type() != CollectionEditor::JSONCOLLECTIONMODEL_TYPENAME) {
+    } else if (node.type() != CollectionEditorConstants::JSONCOLLECTIONMODEL_TYPENAME) {
         emitRenameWarning(tr("Invalid node type"));
         return;
     }
 
-    QString sourceFileAddress = CollectionEditor::getSourceCollectionPath(node);
+    QString sourceFileAddress = CollectionEditorUtils::getSourceCollectionPath(node);
 
     QFileInfo sourceFileInfo(sourceFileAddress);
     if (!sourceFileInfo.isFile()) {
@@ -513,15 +515,15 @@ void CollectionSourceModel::onCollectionsRemoved(CollectionListModel *collection
         return;
     }
 
-    if (node.type() == CollectionEditor::CSVCOLLECTIONMODEL_TYPENAME) {
+    if (node.type() == CollectionEditorConstants::CSVCOLLECTIONMODEL_TYPENAME) {
         removeSource(node);
         return;
-    } else if (node.type() != CollectionEditor::JSONCOLLECTIONMODEL_TYPENAME) {
+    } else if (node.type() != CollectionEditorConstants::JSONCOLLECTIONMODEL_TYPENAME) {
         emitDeleteWarning(tr("Invalid node type"));
         return;
     }
 
-    QString sourceFileAddress = CollectionEditor::getSourceCollectionPath(node);
+    QString sourceFileAddress = CollectionEditorUtils::getSourceCollectionPath(node);
 
     QFileInfo sourceFileInfo(sourceFileAddress);
     if (!sourceFileInfo.isFile()) {

src/plugins/qmldesigner/components/collectioneditor/collectionview.cpp

@@ -31,7 +31,7 @@ namespace {
 
 inline bool isStudioCollectionModel(const QmlDesigner::ModelNode &node)
 {
-    using namespace QmlDesigner::CollectionEditor;
+    using namespace QmlDesigner::CollectionEditorConstants;
     return node.metaInfo().typeName() == JSONCOLLECTIONMODEL_TYPENAME
            || node.metaInfo().typeName() == CSVCOLLECTIONMODEL_TYPENAME;
 }
@@ -151,7 +151,7 @@ void CollectionView::variantPropertiesChanged(const QList<VariantProperty> &prop
         if (isStudioCollectionModel(node)) {
             if (property.name() == "objectName")
                 m_widget->sourceModel()->updateNodeName(node);
-            else if (property.name() == CollectionEditor::SOURCEFILE_PROPERTY)
+            else if (property.name() == CollectionEditorConstants::SOURCEFILE_PROPERTY)
                 m_widget->sourceModel()->updateNodeSource(node);
         }
     }
@@ -169,7 +169,8 @@ void CollectionView::selectedNodesChanged(const QList<ModelNode> &selectedNodeLi
     bool singleSelectedHasModelProperty = false;
     if (singleNonCollectionNodeSelected) {
         const ModelNode selectedNode = selectedNodeList.first();
-        singleSelectedHasModelProperty = CollectionEditor::canAcceptCollectionAsModel(selectedNode);
+        singleSelectedHasModelProperty = CollectionEditorUtils::canAcceptCollectionAsModel(
+            selectedNode);
     }
 
     m_widget->setTargetNodeSelected(singleSelectedHasModelProperty);
@@ -204,7 +205,7 @@ void CollectionView::addResource(const QUrl &url, const QString &name, const QSt
                                                  resourceMetaInfo.majorVersion(),
                                                  resourceMetaInfo.minorVersion());
         VariantProperty sourceProperty = resourceNode.variantProperty(
-            CollectionEditor::SOURCEFILE_PROPERTY);
+            CollectionEditorConstants::SOURCEFILE_PROPERTY);
         VariantProperty nameProperty = resourceNode.variantProperty("objectName");
         sourceProperty.setValue(sourceAddress);
         nameProperty.setValue(name);
@@ -252,18 +253,18 @@ void CollectionView::refreshModel()
 
 NodeMetaInfo CollectionView::jsonCollectionMetaInfo() const
 {
-    return model()->metaInfo(CollectionEditor::JSONCOLLECTIONMODEL_TYPENAME);
+    return model()->metaInfo(CollectionEditorConstants::JSONCOLLECTIONMODEL_TYPENAME);
 }
 
 NodeMetaInfo CollectionView::csvCollectionMetaInfo() const
 {
-    return model()->metaInfo(CollectionEditor::CSVCOLLECTIONMODEL_TYPENAME);
+    return model()->metaInfo(CollectionEditorConstants::CSVCOLLECTIONMODEL_TYPENAME);
 }
 
 void CollectionView::ensureStudioModelImport()
 {
     executeInTransaction(__FUNCTION__, [&] {
-        Import import = Import::createLibraryImport(CollectionEditor::COLLECTIONMODEL_IMPORT);
+        Import import = Import::createLibraryImport(CollectionEditorConstants::COLLECTIONMODEL_IMPORT);
         try {
             if (!model()->hasImport(import, true, true))
                 model()->changeImports({import}, {});

src/plugins/qmldesigner/components/collectioneditor/collectionwidget.cpp

@@ -6,7 +6,6 @@
 #include "collectiondetailsmodel.h"
 #include "collectiondetailssortfiltermodel.h"
 #include "collectioneditorutils.h"
-#include "collectionimporttools.h"
 #include "collectionsourcemodel.h"
 #include "collectionview.h"
 #include "qmldesignerconstants.h"
@@ -216,7 +215,7 @@ bool CollectionWidget::addCollection(const QString &collectionName,
 
         if (collectionType == "json") {
             QJsonObject jsonObject;
-            jsonObject.insert(collectionName, CollectionEditor::defaultCollectionArray());
+            jsonObject.insert(collectionName, CollectionEditorUtils::defaultCollectionArray());
 
             QFile sourceFile(sourcePath);
             if (!sourceFile.open(QFile::WriteOnly)) {
@@ -258,10 +257,8 @@ bool CollectionWidget::addCollection(const QString &collectionName,
         }
     } else if (collectionType == "json") {
         QString errorMsg;
-        bool added = m_sourceModel->addCollectionToSource(node,
+        bool added = m_sourceModel->addCollectionToSource(
-                                                          collectionName,
+            node, collectionName, CollectionEditorUtils::defaultCollectionArray(), &errorMsg);
-                                                          CollectionEditor::defaultCollectionArray(),
-                                                          &errorMsg);
         if (!added)
             warn(tr("Can not add a model to the JSON file"), errorMsg);
         return added;
@@ -274,10 +271,10 @@ bool CollectionWidget::importToJson(const QVariant &sourceNode,
                                     const QString &collectionName,
                                     const QUrl &url)
 {
-    using CollectionEditor::SourceFormat;
+    using CollectionEditorConstants::SourceFormat;
     using Utils::FilePath;
     const ModelNode node = sourceNode.value<ModelNode>();
-    const SourceFormat nodeFormat = CollectionEditor::getSourceCollectionFormat(node);
+    const SourceFormat nodeFormat = CollectionEditorUtils::getSourceCollectionFormat(node);
     QTC_ASSERT(node.isValid() && nodeFormat == SourceFormat::Json, return false);
 
     FilePath fileInfo = FilePath::fromUserInput(url.isLocalFile() ? url.toLocalFile()
@@ -287,9 +284,9 @@ bool CollectionWidget::importToJson(const QVariant &sourceNode,
     QJsonArray loadedCollection;
 
     if (fileInfo.suffix() == "json")
-        loadedCollection = CollectionEditor::ImportTools::loadAsSingleJsonCollection(url);
+        loadedCollection = CollectionEditorUtils::loadAsSingleJsonCollection(url);
     else if (fileInfo.suffix() == "csv")
-        loadedCollection = CollectionEditor::ImportTools::loadAsCsvCollection(url);
+        loadedCollection = CollectionEditorUtils::loadAsCsvCollection(url);
 
     if (!loadedCollection.isEmpty()) {
         const QString newCollectionName = generateUniqueCollectionName(node, collectionName);
@@ -327,7 +324,7 @@ bool CollectionWidget::addCollectionToDataStore(const QString &collectionName)
     bool added = m_sourceModel->addCollectionToSource(node,
                                                       generateUniqueCollectionName(node,
                                                                                    collectionName),
-                                                      CollectionEditor::defaultCollectionArray(),
+                                                      CollectionEditorUtils::defaultCollectionArray(),
                                                       &errorMsg);
     if (!added)
         warn(tr("Failed to add a model to the default model group"), errorMsg);
@@ -343,7 +340,7 @@ void CollectionWidget::assignCollectionToSelectedNode(const QString collectionNa
 void CollectionWidget::ensureDataStoreExists()
 {
     bool filesJustCreated = false;
-    bool filesExist = CollectionEditor::ensureDataStoreExists(filesJustCreated);
+    bool filesExist = CollectionEditorUtils::ensureDataStoreExists(filesJustCreated);
     if (filesExist && filesJustCreated)
         m_view->resetDataStoreNode();
 }

src/plugins/qmldesigner/components/collectioneditor/datastoremodelnode.cpp

@@ -41,10 +41,11 @@ QmlDesigner::PropertyNameList createNameList(const QmlDesigner::ModelNode &node)
     using QmlDesigner::AbstractProperty;
     using QmlDesigner::PropertyName;
     using QmlDesigner::PropertyNameList;
-    static PropertyNameList defaultsNodeProps = {"id",
+    static PropertyNameList defaultsNodeProps = {
-                                                 QmlDesigner::CollectionEditor::SOURCEFILE_PROPERTY,
+        "id",
-                                                 QmlDesigner::CollectionEditor::JSONCHILDMODELNAME_PROPERTY,
+        QmlDesigner::CollectionEditorConstants::SOURCEFILE_PROPERTY,
-                                                 "backend"};
+        QmlDesigner::CollectionEditorConstants::JSONCHILDMODELNAME_PROPERTY,
+        "backend"};
     PropertyNameList dynamicPropertyNames = Utils::transform(
         node.dynamicProperties(),
         [](const AbstractProperty &property) -> PropertyName { return property.name(); });
@@ -57,8 +58,8 @@ QmlDesigner::PropertyNameList createNameList(const QmlDesigner::ModelNode &node)
 bool isValidCollectionPropertyName(const QString &collectionId)
 {
     static const QmlDesigner::PropertyNameList reservedKeywords = {
-        QmlDesigner::CollectionEditor::SOURCEFILE_PROPERTY,
+        QmlDesigner::CollectionEditorConstants::SOURCEFILE_PROPERTY,
-        QmlDesigner::CollectionEditor::JSONBACKEND_TYPENAME,
+        QmlDesigner::CollectionEditorConstants::JSONBACKEND_TYPENAME,
         "backend",
         "models",
     };
@@ -83,8 +84,9 @@ QMap<QString, QmlDesigner::PropertyName> getModelIdMap(const QmlDesigner::ModelN
             continue;
 
         ModelNode childNode = nodeProperty.modelNode();
-        if (childNode.hasProperty(CollectionEditor::JSONCHILDMODELNAME_PROPERTY)) {
+        if (childNode.hasProperty(CollectionEditorConstants::JSONCHILDMODELNAME_PROPERTY)) {
-            QString modelName = childNode.property(CollectionEditor::JSONCHILDMODELNAME_PROPERTY)
+            QString modelName = childNode
+                                    .property(CollectionEditorConstants::JSONCHILDMODELNAME_PROPERTY)
                                     .toVariantProperty()
                                     .value()
                                     .toString();
@@ -136,15 +138,16 @@ void DataStoreModelNode::reloadModel()
     }
     bool forceUpdate = false;
 
-    const FilePath dataStoreQmlPath = CollectionEditor::dataStoreQmlFilePath();
+    const FilePath dataStoreQmlPath = CollectionEditorUtils::dataStoreQmlFilePath();
-    const FilePath dataStoreJsonPath = CollectionEditor::dataStoreJsonFilePath();
+    const FilePath dataStoreJsonPath = CollectionEditorUtils::dataStoreJsonFilePath();
     QUrl dataStoreQmlUrl = dataStoreQmlPath.toUrl();
 
     if (dataStoreQmlPath.exists() && dataStoreJsonPath.exists()) {
         if (!m_model.get() || m_model->fileUrl() != dataStoreQmlUrl) {
-            m_model = Model::create(CollectionEditor::JSONCOLLECTIONMODEL_TYPENAME, 1, 1);
+            m_model = Model::create(CollectionEditorConstants::JSONCOLLECTIONMODEL_TYPENAME, 1, 1);
             forceUpdate = true;
-            Import import = Import::createLibraryImport(CollectionEditor::COLLECTIONMODEL_IMPORT);
+            Import import = Import::createLibraryImport(
+                CollectionEditorConstants::COLLECTIONMODEL_IMPORT);
             try {
                 if (!m_model->hasImport(import, true, true))
                     m_model->changeImports({import}, {});
@@ -247,8 +250,9 @@ void DataStoreModelNode::updateDataStoreProperties()
             continue;
 
         ModelNode childNode = nodeProprty.modelNode();
-        if (childNode.hasProperty(CollectionEditor::JSONCHILDMODELNAME_PROPERTY)) {
+        if (childNode.hasProperty(CollectionEditorConstants::JSONCHILDMODELNAME_PROPERTY)) {
-            QString modelName = childNode.property(CollectionEditor::JSONCHILDMODELNAME_PROPERTY)
+            QString modelName = childNode
+                                    .property(CollectionEditorConstants::JSONCHILDMODELNAME_PROPERTY)
                                     .toVariantProperty()
                                     .value()
                                     .toString();
@@ -271,12 +275,13 @@ void DataStoreModelNode::updateDataStoreProperties()
         addCollectionNameToTheModel(collectionName, getUniquePropertyName(collectionName));
 
     // Backend Property
-    ModelNode backendNode = model()->createModelNode(CollectionEditor::JSONBACKEND_TYPENAME);
+    ModelNode backendNode = model()->createModelNode(CollectionEditorConstants::JSONBACKEND_TYPENAME);
     NodeProperty backendProperty = rootNode.nodeProperty("backend");
-    backendProperty.setDynamicTypeNameAndsetModelNode(CollectionEditor::JSONBACKEND_TYPENAME,
+    backendProperty.setDynamicTypeNameAndsetModelNode(CollectionEditorConstants::JSONBACKEND_TYPENAME,
                                                       backendNode);
     // Source Property
-    VariantProperty sourceProp = rootNode.variantProperty(CollectionEditor::SOURCEFILE_PROPERTY);
+    VariantProperty sourceProp = rootNode.variantProperty(
+        CollectionEditorConstants::SOURCEFILE_PROPERTY);
     sourceProp.setValue(m_dataRelativePath);
 }
 
@@ -321,7 +326,7 @@ void DataStoreModelNode::addCollectionNameToTheModel(const QString &collectionNa
 
     ModelNode collectionNode = model()->createModelNode(CHILDLISTMODEL_TYPENAME);
     VariantProperty modelNameProperty = collectionNode.variantProperty(
-        CollectionEditor::JSONCHILDMODELNAME_PROPERTY);
+        CollectionEditorConstants::JSONCHILDMODELNAME_PROPERTY);
     modelNameProperty.setValue(collectionName);
 
     NodeProperty nodeProp = rootNode.nodeProperty(dataStorePropertyName);
@@ -393,7 +398,7 @@ void DataStoreModelNode::renameCollection(const QString &oldName, const QString
             NodeProperty collectionNode = dataStoreNode.property(oldPropertyName).toNodeProperty();
             if (collectionNode.isValid()) {
                 VariantProperty modelNameProperty = collectionNode.modelNode().variantProperty(
-                    CollectionEditor::JSONCHILDMODELNAME_PROPERTY);
+                    CollectionEditorConstants::JSONCHILDMODELNAME_PROPERTY);
                 modelNameProperty.setValue(newName);
                 m_collectionPropertyNames.remove(oldName);
                 m_collectionPropertyNames.insert(newName, collectionNode.name());
@@ -426,7 +431,7 @@ void DataStoreModelNode::assignCollectionToNode(AbstractView *view,
 {
     QTC_ASSERT(targetNode.isValid(), return);
 
-    if (!CollectionEditor::canAcceptCollectionAsModel(targetNode))
+    if (!CollectionEditorUtils::canAcceptCollectionAsModel(targetNode))
         return;
 
     if (!m_collectionPropertyNames.contains(collectionName)) {