feedc0de/qt-creator
1
0
Fork 0
forked from qt-creator/qt-creator
Code Pull Requests Activity

QmlDesigner: Rename ProjectData into DirectoryInfo

Browse Source 
The design is now directory based. So the name should reflect that.

Task-number: QDS-12665
Change-Id: I7479c37357a4fd33f5f3b4c93d63d2fdd4ca6ef9
Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
Reviewed-by: <github-actions-qt-creator@cristianadam.eu>
Reviewed-by: Qt CI Patch Build Bot <ci_patchbuild_bot@qt.io>
This commit is contained in:
Marco Bubke
2024-05-06 17:23:29 +02:00
parent dd10b5972c
commit fa07abf6d8
20 changed files with 716 additions and 712 deletions
Download Patch File Download Diff File Expand all files Collapse all files

144
src/plugins/qmldesigner/designercore/projectstorage/projectstorage.cpp
View File

@@ -502,25 +502,25 @@ struct ProjectStorage::Statements
"DELETE FROM exportedTypeNames WHERE exportedTypeNameId=?", database}; "DELETE FROM exportedTypeNames WHERE exportedTypeNameId=?", database};
Sqlite::WriteStatement<2> updateExportedTypeNameTypeIdStatement{ Sqlite::WriteStatement<2> updateExportedTypeNameTypeIdStatement{
"UPDATE exportedTypeNames SET typeId=?2 WHERE exportedTypeNameId=?1", database}; "UPDATE exportedTypeNames SET typeId=?2 WHERE exportedTypeNameId=?1", database};
mutable Sqlite::ReadStatement<4, 1> selectProjectDatasForSourceIdsStatement{ mutable Sqlite::ReadStatement<4, 1> selectDirectoryInfosForSourceIdsStatement{
"SELECT projectSourceId, sourceId, moduleId, fileType FROM projectDatas WHERE " "SELECT directorySourceId, sourceId, moduleId, fileType FROM directoryInfos WHERE "
"projectSourceId IN carray(?1) ORDER BY projectSourceId, sourceId", "directorySourceId IN carray(?1) ORDER BY directorySourceId, sourceId",
database}; database};
Sqlite::WriteStatement<4> insertProjectDataStatement{ Sqlite::WriteStatement<4> insertDirectoryInfoStatement{
"INSERT INTO projectDatas(projectSourceId, sourceId, " "INSERT INTO directoryInfos(directorySourceId, sourceId, "
"moduleId, fileType) VALUES(?1, ?2, ?3, ?4)", "moduleId, fileType) VALUES(?1, ?2, ?3, ?4)",
database}; database};
Sqlite::WriteStatement<2> deleteProjectDataStatement{ Sqlite::WriteStatement<2> deleteDirectoryInfoStatement{
"DELETE FROM projectDatas WHERE projectSourceId=?1 AND sourceId=?2", database}; "DELETE FROM directoryInfos WHERE directorySourceId=?1 AND sourceId=?2", database};
Sqlite::WriteStatement<4> updateProjectDataStatement{ Sqlite::WriteStatement<4> updateDirectoryInfoStatement{
"UPDATE projectDatas SET moduleId=?3, fileType=?4 WHERE projectSourceId=?1 AND sourceId=?2", "UPDATE directoryInfos SET moduleId=?3, fileType=?4 WHERE directorySourceId=?1 AND sourceId=?2",
database}; database};
mutable Sqlite::ReadStatement<4, 1> selectProjectDatasForSourceIdStatement{ mutable Sqlite::ReadStatement<4, 1> selectDirectoryInfosForSourceIdStatement{
"SELECT projectSourceId, sourceId, moduleId, fileType FROM projectDatas WHERE " "SELECT directorySourceId, sourceId, moduleId, fileType FROM directoryInfos WHERE "
"projectSourceId=?1", "directorySourceId=?1",
database}; database};
mutable Sqlite::ReadStatement<4, 1> selectProjectDataForSourceIdStatement{ mutable Sqlite::ReadStatement<4, 1> selectDirectoryInfoForSourceIdStatement{
"SELECT projectSourceId, sourceId, moduleId, fileType FROM projectDatas WHERE " "SELECT directorySourceId, sourceId, moduleId, fileType FROM directoryInfos WHERE "
"sourceId=?1 LIMIT 1", "sourceId=?1 LIMIT 1",
database}; database};
mutable Sqlite::ReadStatement<1, 1> selectTypeIdsForSourceIdsStatement{ mutable Sqlite::ReadStatement<1, 1> selectTypeIdsForSourceIdsStatement{
@@ -745,7 +745,7 @@ public:
createModuleExportedImportsTable(database, moduleIdColumn); createModuleExportedImportsTable(database, moduleIdColumn);
createDocumentImportsTable(database, moduleIdColumn); createDocumentImportsTable(database, moduleIdColumn);
createFileStatusesTable(database); createFileStatusesTable(database);
createProjectDatasTable(database); createDirectoryInfosTable(database);
createPropertyEditorPathsTable(database); createPropertyEditorPathsTable(database);
createTypeAnnotionsTable(database); createTypeAnnotionsTable(database);
} }
@@ -1063,19 +1063,19 @@ public:
table.initialize(database); table.initialize(database);
} }
void createProjectDatasTable(Database &database) void createDirectoryInfosTable(Database &database)
{ {
Sqlite::StrictTable table; Sqlite::StrictTable table;
table.setUseIfNotExists(true); table.setUseIfNotExists(true);
table.setUseWithoutRowId(true); table.setUseWithoutRowId(true);
table.setName("projectDatas"); table.setName("directoryInfos");
auto &projectSourceIdColumn = table.addColumn("projectSourceId", auto &directorySourceIdColumn = table.addColumn("directorySourceId",
Sqlite::StrictColumnType::Integer); Sqlite::StrictColumnType::Integer);
auto &sourceIdColumn = table.addColumn("sourceId", Sqlite::StrictColumnType::Integer); auto &sourceIdColumn = table.addColumn("sourceId", Sqlite::StrictColumnType::Integer);
table.addColumn("moduleId", Sqlite::StrictColumnType::Integer); table.addColumn("moduleId", Sqlite::StrictColumnType::Integer);
table.addColumn("fileType", Sqlite::StrictColumnType::Integer); table.addColumn("fileType", Sqlite::StrictColumnType::Integer);
table.addPrimaryKeyContraint({projectSourceIdColumn, sourceIdColumn}); table.addPrimaryKeyContraint({directorySourceIdColumn, sourceIdColumn});
table.addUniqueIndex({sourceIdColumn}); table.addUniqueIndex({sourceIdColumn});
table.initialize(database); table.initialize(database);
@@ -1196,7 +1196,7 @@ void ProjectStorage::synchronize(Storage::Synchronization::SynchronizationPackag
linkAliases(insertedAliasPropertyDeclarations, updatedAliasPropertyDeclarations); linkAliases(insertedAliasPropertyDeclarations, updatedAliasPropertyDeclarations);
synchronizeProjectDatas(package.projectDatas, package.updatedProjectSourceIds); synchronizeDirectoryInfos(package.directoryInfos, package.updatedProjectSourceIds);
commonTypeCache_.resetTypeIds(); commonTypeCache_.resetTypeIds();
}); });
@@ -2113,53 +2113,53 @@ FileStatus ProjectStorage::fetchFileStatus(SourceId sourceId) const
return fileStatus; return fileStatus;
} }
std::optional<Storage::Synchronization::ProjectData> ProjectStorage::fetchProjectData(SourceId sourceId) const std::optional<Storage::Synchronization::DirectoryInfo> ProjectStorage::fetchDirectoryInfo(SourceId sourceId) const
{ {
using NanotraceHR::keyValue; using NanotraceHR::keyValue;
NanotraceHR::Tracer tracer{"fetch project data"_t, NanotraceHR::Tracer tracer{"fetch project data"_t,
projectStorageCategory(), projectStorageCategory(),
keyValue("source id", sourceId)}; keyValue("source id", sourceId)};
auto projectData = s->selectProjectDataForSourceIdStatement auto directoryInfo = s->selectDirectoryInfoForSourceIdStatement
.optionalValueWithTransaction<Storage::Synchronization::ProjectData>( .optionalValueWithTransaction<Storage::Synchronization::DirectoryInfo>(
sourceId); sourceId);
tracer.end(keyValue("project data", projectData)); tracer.end(keyValue("project data", directoryInfo));
return projectData; return directoryInfo;
} }
Storage::Synchronization::ProjectDatas ProjectStorage::fetchProjectDatas(SourceId projectSourceId) const Storage::Synchronization::DirectoryInfos ProjectStorage::fetchDirectoryInfos(SourceId directorySourceId) const
{ {
using NanotraceHR::keyValue; using NanotraceHR::keyValue;
NanotraceHR::Tracer tracer{"fetch project datas by source id"_t, NanotraceHR::Tracer tracer{"fetch project datas by source id"_t,
projectStorageCategory(), projectStorageCategory(),
keyValue("source id", projectSourceId)}; keyValue("source id", directorySourceId)};
auto projectDatas = s->selectProjectDatasForSourceIdStatement auto directoryInfos = s->selectDirectoryInfosForSourceIdStatement
.valuesWithTransaction<Storage::Synchronization::ProjectData, 1024>( .valuesWithTransaction<Storage::Synchronization::DirectoryInfo, 1024>(
projectSourceId); directorySourceId);
tracer.end(keyValue("project datas", projectDatas)); tracer.end(keyValue("project datas", directoryInfos));
return projectDatas; return directoryInfos;
} }
Storage::Synchronization::ProjectDatas ProjectStorage::fetchProjectDatas( Storage::Synchronization::DirectoryInfos ProjectStorage::fetchDirectoryInfos(
const SourceIds &projectSourceIds) const const SourceIds &directorySourceIds) const
{ {
using NanotraceHR::keyValue; using NanotraceHR::keyValue;
NanotraceHR::Tracer tracer{"fetch project datas by source ids"_t, NanotraceHR::Tracer tracer{"fetch project datas by source ids"_t,
projectStorageCategory(), projectStorageCategory(),
keyValue("source ids", projectSourceIds)}; keyValue("source ids", directorySourceIds)};
auto projectDatas = s->selectProjectDatasForSourceIdsStatement auto directoryInfos = s->selectDirectoryInfosForSourceIdsStatement
.valuesWithTransaction<Storage::Synchronization::ProjectData, 64>( .valuesWithTransaction<Storage::Synchronization::DirectoryInfo, 64>(
toIntegers(projectSourceIds)); toIntegers(directorySourceIds));
tracer.end(keyValue("project datas", projectDatas)); tracer.end(keyValue("project datas", directoryInfos));
return projectDatas; return directoryInfos;
} }
void ProjectStorage::setPropertyEditorPathId(TypeId typeId, SourceId pathId) void ProjectStorage::setPropertyEditorPathId(TypeId typeId, SourceId pathId)
@@ -2465,74 +2465,74 @@ void ProjectStorage::synchronizeTypes(Storage::Synchronization::Types &types,
syncDefaultProperties(types); syncDefaultProperties(types);
} }
void ProjectStorage::synchronizeProjectDatas(Storage::Synchronization::ProjectDatas &projectDatas, void ProjectStorage::synchronizeDirectoryInfos(Storage::Synchronization::DirectoryInfos &directoryInfos,
const SourceIds &updatedProjectSourceIds) const SourceIds &updatedProjectSourceIds)
{ {
NanotraceHR::Tracer tracer{"synchronize project datas"_t, projectStorageCategory()}; NanotraceHR::Tracer tracer{"synchronize project datas"_t, projectStorageCategory()};
auto compareKey = [](auto &&first, auto &&second) { auto compareKey = [](auto &&first, auto &&second) {
auto projectSourceIdDifference = first.projectSourceId - second.projectSourceId; auto directorySourceIdDifference = first.directorySourceId - second.directorySourceId;
if (projectSourceIdDifference != 0) if (directorySourceIdDifference != 0)
return projectSourceIdDifference; return directorySourceIdDifference;
return first.sourceId - second.sourceId; return first.sourceId - second.sourceId;
}; };
std::sort(projectDatas.begin(), projectDatas.end(), [&](auto &&first, auto &&second) { std::sort(directoryInfos.begin(), directoryInfos.end(), [&](auto &&first, auto &&second) {
return std::tie(first.projectSourceId, first.sourceId) return std::tie(first.directorySourceId, first.sourceId)
< std::tie(second.projectSourceId, second.sourceId); < std::tie(second.directorySourceId, second.sourceId);
}); });
auto range = s->selectProjectDatasForSourceIdsStatement.range<Storage::Synchronization::ProjectData>( auto range = s->selectDirectoryInfosForSourceIdsStatement.range<Storage::Synchronization::DirectoryInfo>(
toIntegers(updatedProjectSourceIds)); toIntegers(updatedProjectSourceIds));
auto insert = [&](const Storage::Synchronization::ProjectData &projectData) { auto insert = [&](const Storage::Synchronization::DirectoryInfo &directoryInfo) {
using NanotraceHR::keyValue; using NanotraceHR::keyValue;
NanotraceHR::Tracer tracer{"insert project data"_t, NanotraceHR::Tracer tracer{"insert project data"_t,
projectStorageCategory(), projectStorageCategory(),
keyValue("project data", projectData)}; keyValue("project data", directoryInfo)};
if (!projectData.projectSourceId) if (!directoryInfo.directorySourceId)
throw ProjectDataHasInvalidProjectSourceId{}; throw DirectoryInfoHasInvalidProjectSourceId{};
if (!projectData.sourceId) if (!directoryInfo.sourceId)
throw ProjectDataHasInvalidSourceId{}; throw DirectoryInfoHasInvalidSourceId{};
s->insertProjectDataStatement.write(projectData.projectSourceId, s->insertDirectoryInfoStatement.write(directoryInfo.directorySourceId,
projectData.sourceId, directoryInfo.sourceId,
projectData.moduleId, directoryInfo.moduleId,
projectData.fileType); directoryInfo.fileType);
}; };
auto update = [&](const Storage::Synchronization::ProjectData &projectDataFromDatabase, auto update = [&](const Storage::Synchronization::DirectoryInfo &directoryInfoFromDatabase,
const Storage::Synchronization::ProjectData &projectData) { const Storage::Synchronization::DirectoryInfo &directoryInfo) {
if (projectDataFromDatabase.fileType != projectData.fileType if (directoryInfoFromDatabase.fileType != directoryInfo.fileType
|| !compareInvalidAreTrue(projectDataFromDatabase.moduleId, projectData.moduleId)) { || !compareInvalidAreTrue(directoryInfoFromDatabase.moduleId, directoryInfo.moduleId)) {
using NanotraceHR::keyValue; using NanotraceHR::keyValue;
NanotraceHR::Tracer tracer{"update project data"_t, NanotraceHR::Tracer tracer{"update project data"_t,
projectStorageCategory(), projectStorageCategory(),
keyValue("project data", projectData), keyValue("project data", directoryInfo),
keyValue("project data from database", projectDataFromDatabase)}; keyValue("project data from database", directoryInfoFromDatabase)};
s->updateProjectDataStatement.write(projectData.projectSourceId, s->updateDirectoryInfoStatement.write(directoryInfo.directorySourceId,
projectData.sourceId, directoryInfo.sourceId,
projectData.moduleId, directoryInfo.moduleId,
projectData.fileType); directoryInfo.fileType);
return Sqlite::UpdateChange::Update; return Sqlite::UpdateChange::Update;
} }
return Sqlite::UpdateChange::No; return Sqlite::UpdateChange::No;
}; };
auto remove = [&](const Storage::Synchronization::ProjectData &projectData) { auto remove = [&](const Storage::Synchronization::DirectoryInfo &directoryInfo) {
using NanotraceHR::keyValue; using NanotraceHR::keyValue;
NanotraceHR::Tracer tracer{"remove project data"_t, NanotraceHR::Tracer tracer{"remove project data"_t,
projectStorageCategory(), projectStorageCategory(),
keyValue("project data", projectData)}; keyValue("project data", directoryInfo)};
s->deleteProjectDataStatement.write(projectData.projectSourceId, projectData.sourceId); s->deleteDirectoryInfoStatement.write(directoryInfo.directorySourceId, directoryInfo.sourceId);
}; };
Sqlite::insertUpdateDelete(range, projectDatas, compareKey, insert, update, remove); Sqlite::insertUpdateDelete(range, directoryInfos, compareKey, insert, update, remove);
} }
void ProjectStorage::synchronizeFileStatuses(FileStatuses &fileStatuses, void ProjectStorage::synchronizeFileStatuses(FileStatuses &fileStatuses,

8
src/plugins/qmldesigner/designercore/projectstorage/projectstorage.h
View File

@@ -229,11 +229,11 @@ public:
FileStatus fetchFileStatus(SourceId sourceId) const override; FileStatus fetchFileStatus(SourceId sourceId) const override;
std::optional<Storage::Synchronization::ProjectData> fetchProjectData(SourceId sourceId) const override; std::optional<Storage::Synchronization::DirectoryInfo> fetchDirectoryInfo(SourceId sourceId) const override;
Storage::Synchronization::ProjectDatas fetchProjectDatas(SourceId projectSourceId) const override; Storage::Synchronization::DirectoryInfos fetchDirectoryInfos(SourceId directorySourceId) const override;
Storage::Synchronization::ProjectDatas fetchProjectDatas(const SourceIds &projectSourceIds) const; Storage::Synchronization::DirectoryInfos fetchDirectoryInfos(const SourceIds &directorySourceIds) const;
void setPropertyEditorPathId(TypeId typeId, SourceId pathId); void setPropertyEditorPathId(TypeId typeId, SourceId pathId);
@@ -560,7 +560,7 @@ private:
Prototypes &relinkableExtensions, Prototypes &relinkableExtensions,
const SourceIds &updatedSourceIds); const SourceIds &updatedSourceIds);
void synchronizeProjectDatas(Storage::Synchronization::ProjectDatas &projectDatas, void synchronizeDirectoryInfos(Storage::Synchronization::DirectoryInfos &directoryInfos,
const SourceIds &updatedProjectSourceIds); const SourceIds &updatedProjectSourceIds);
void synchronizeFileStatuses(FileStatuses &fileStatuses, const SourceIds &updatedSourceIds); void synchronizeFileStatuses(FileStatuses &fileStatuses, const SourceIds &updatedSourceIds);

18
src/plugins/qmldesigner/designercore/projectstorage/projectstorageexceptions.cpp
View File

@@ -148,32 +148,32 @@ const char *CannotParseQmlDocumentFile::what() const noexcept
return "Cannot parse qml types file!"; return "Cannot parse qml types file!";
} }
ProjectDataHasInvalidProjectSourceId::ProjectDataHasInvalidProjectSourceId() DirectoryInfoHasInvalidProjectSourceId::DirectoryInfoHasInvalidProjectSourceId()
{ {
category().threadEvent("ProjectDataHasInvalidProjectSourceId"_t); category().threadEvent("DirectoryInfoHasInvalidProjectSourceId"_t);
} }
const char *ProjectDataHasInvalidProjectSourceId::what() const noexcept const char *DirectoryInfoHasInvalidProjectSourceId::what() const noexcept
{ {
return "The project source id is invalid!"; return "The project source id is invalid!";
} }
ProjectDataHasInvalidSourceId::ProjectDataHasInvalidSourceId() DirectoryInfoHasInvalidSourceId::DirectoryInfoHasInvalidSourceId()
{ {
category().threadEvent("ProjectDataHasInvalidSourceId"_t); category().threadEvent("DirectoryInfoHasInvalidSourceId"_t);
} }
const char *ProjectDataHasInvalidSourceId::what() const noexcept const char *DirectoryInfoHasInvalidSourceId::what() const noexcept
{ {
return "The source id is invalid!"; return "The source id is invalid!";
} }
ProjectDataHasInvalidModuleId::ProjectDataHasInvalidModuleId() DirectoryInfoHasInvalidModuleId::DirectoryInfoHasInvalidModuleId()
{ {
category().threadEvent("ProjectDataHasInvalidModuleId"_t); category().threadEvent("DirectoryInfoHasInvalidModuleId"_t);
} }
const char *ProjectDataHasInvalidModuleId::what() const noexcept const char *DirectoryInfoHasInvalidModuleId::what() const noexcept
{ {
return "The module id is invalid!"; return "The module id is invalid!";
} }

12
src/plugins/qmldesigner/designercore/projectstorage/projectstorageexceptions.h
View File

@@ -130,24 +130,24 @@ public:
const char *what() const noexcept override; const char *what() const noexcept override;
}; };
class QMLDESIGNERCORE_EXPORT ProjectDataHasInvalidProjectSourceId : public ProjectStorageError class QMLDESIGNERCORE_EXPORT DirectoryInfoHasInvalidProjectSourceId : public ProjectStorageError
{ {
public: public:
ProjectDataHasInvalidProjectSourceId(); DirectoryInfoHasInvalidProjectSourceId();
const char *what() const noexcept override; const char *what() const noexcept override;
}; };
class QMLDESIGNERCORE_EXPORT ProjectDataHasInvalidSourceId : public ProjectStorageError class QMLDESIGNERCORE_EXPORT DirectoryInfoHasInvalidSourceId : public ProjectStorageError
{ {
public: public:
ProjectDataHasInvalidSourceId(); DirectoryInfoHasInvalidSourceId();
const char *what() const noexcept override; const char *what() const noexcept override;
}; };
class QMLDESIGNERCORE_EXPORT ProjectDataHasInvalidModuleId : public ProjectStorageError class QMLDESIGNERCORE_EXPORT DirectoryInfoHasInvalidModuleId : public ProjectStorageError
{ {
public: public:
ProjectDataHasInvalidModuleId(); DirectoryInfoHasInvalidModuleId();
const char *what() const noexcept override; const char *what() const noexcept override;
}; };

4
src/plugins/qmldesigner/designercore/projectstorage/projectstorageinterface.h
View File

@@ -80,8 +80,8 @@ public:
virtual bool isBasedOn(TypeId, TypeId, TypeId, TypeId, TypeId, TypeId, TypeId, TypeId) const = 0; virtual bool isBasedOn(TypeId, TypeId, TypeId, TypeId, TypeId, TypeId, TypeId, TypeId) const = 0;
virtual FileStatus fetchFileStatus(SourceId sourceId) const = 0; virtual FileStatus fetchFileStatus(SourceId sourceId) const = 0;
virtual Storage::Synchronization::ProjectDatas fetchProjectDatas(SourceId sourceId) const = 0; virtual Storage::Synchronization::DirectoryInfos fetchDirectoryInfos(SourceId sourceId) const = 0;
virtual std::optional<Storage::Synchronization::ProjectData> fetchProjectData(SourceId sourceId) const = 0; virtual std::optional<Storage::Synchronization::DirectoryInfo> fetchDirectoryInfo(SourceId sourceId) const = 0;
virtual SourceId propertyEditorPathId(TypeId typeId) const = 0; virtual SourceId propertyEditorPathId(TypeId typeId) const = 0;
virtual const Storage::Info::CommonTypeCache<ProjectStorageType> &commonTypeCache() const = 0; virtual const Storage::Info::CommonTypeCache<ProjectStorageType> &commonTypeCache() const = 0;

30
src/plugins/qmldesigner/designercore/projectstorage/projectstoragetypes.h
View File

@@ -1160,44 +1160,44 @@ public:
using PropertyEditorQmlPaths = std::vector<class PropertyEditorQmlPath>; using PropertyEditorQmlPaths = std::vector<class PropertyEditorQmlPath>;
class ProjectData class DirectoryInfo
{ {
public: public:
ProjectData(SourceId projectSourceId, SourceId sourceId, ModuleId moduleId, FileType fileType) DirectoryInfo(SourceId directorySourceId, SourceId sourceId, ModuleId moduleId, FileType fileType)
: projectSourceId{projectSourceId} : directorySourceId{directorySourceId}
, sourceId{sourceId} , sourceId{sourceId}
, moduleId{moduleId} , moduleId{moduleId}
, fileType{fileType} , fileType{fileType}
{} {}
friend bool operator==(const ProjectData &first, const ProjectData &second) friend bool operator==(const DirectoryInfo &first, const DirectoryInfo &second)
{ {
return first.projectSourceId == second.projectSourceId && first.sourceId == second.sourceId return first.directorySourceId == second.directorySourceId && first.sourceId == second.sourceId
&& first.moduleId.internalId() == second.moduleId.internalId() && first.moduleId.internalId() == second.moduleId.internalId()
&& first.fileType == second.fileType; && first.fileType == second.fileType;
} }
template<typename String> template<typename String>
friend void convertToString(String &string, const ProjectData &projectData) friend void convertToString(String &string, const DirectoryInfo &directoryInfo)
{ {
using NanotraceHR::dictonary; using NanotraceHR::dictonary;
using NanotraceHR::keyValue; using NanotraceHR::keyValue;
auto dict = dictonary(keyValue("project source id", projectData.projectSourceId), auto dict = dictonary(keyValue("project source id", directoryInfo.directorySourceId),
keyValue("source id", projectData.sourceId), keyValue("source id", directoryInfo.sourceId),
keyValue("module id", projectData.moduleId), keyValue("module id", directoryInfo.moduleId),
keyValue("file type", projectData.fileType)); keyValue("file type", directoryInfo.fileType));
convertToString(string, dict); convertToString(string, dict);
} }
public: public:
SourceId projectSourceId; SourceId directorySourceId;
SourceId sourceId; SourceId sourceId;
ModuleId moduleId; ModuleId moduleId;
FileType fileType; FileType fileType;
}; };
using ProjectDatas = std::vector<ProjectData>; using DirectoryInfos = std::vector<DirectoryInfo>;
class TypeAnnotation class TypeAnnotation
{ {
@@ -1291,8 +1291,8 @@ public:
, fileStatuses(std::move(fileStatuses)) , fileStatuses(std::move(fileStatuses))
{} {}
SynchronizationPackage(SourceIds updatedProjectSourceIds, ProjectDatas projectDatas) SynchronizationPackage(SourceIds updatedProjectSourceIds, DirectoryInfos directoryInfos)
: projectDatas(std::move(projectDatas)) : directoryInfos(std::move(directoryInfos))
, updatedProjectSourceIds(std::move(updatedProjectSourceIds)) , updatedProjectSourceIds(std::move(updatedProjectSourceIds))
{} {}
@@ -1302,7 +1302,7 @@ public:
SourceIds updatedSourceIds; SourceIds updatedSourceIds;
SourceIds updatedFileStatusSourceIds; SourceIds updatedFileStatusSourceIds;
FileStatuses fileStatuses; FileStatuses fileStatuses;
ProjectDatas projectDatas; DirectoryInfos directoryInfos;
SourceIds updatedProjectSourceIds; SourceIds updatedProjectSourceIds;
Imports moduleDependencies; Imports moduleDependencies;
SourceIds updatedModuleDependencySourceIds; SourceIds updatedModuleDependencySourceIds;

101
src/plugins/qmldesigner/designercore/projectstorage/projectstorageupdater.cpp
View File

@@ -134,13 +134,13 @@ SourceIds filterNotUpdatedSourceIds(SourceIds updatedSourceIds, SourceIds notUpd
} }
void addSourceIds(SourceIds &sourceIds, void addSourceIds(SourceIds &sourceIds,
const Storage::Synchronization::ProjectDatas &projectDatas, const Storage::Synchronization::DirectoryInfos &directoryInfos,
TracerLiteral message, TracerLiteral message,
Tracer &tracer) Tracer &tracer)
{ {
for (const auto &projectData : projectDatas) { for (const auto &directoryInfo : directoryInfos) {
tracer.tick(message, keyValue("source id", projectData.sourceId)); tracer.tick(message, keyValue("source id", directoryInfo.sourceId));
sourceIds.push_back(projectData.sourceId); sourceIds.push_back(directoryInfo.sourceId);
} }
} }
@@ -311,19 +311,17 @@ void ProjectStorageUpdater::updateQmlTypes(const QStringList &qmlTypesPaths,
keyValue("source id", sourceId), keyValue("source id", sourceId),
keyValue("qml types path", qmlTypesPath)); keyValue("qml types path", qmlTypesPath));
Storage::Synchronization::ProjectData projectData{sourceId, Storage::Synchronization::DirectoryInfo directoryInfo{
sourceId, sourceId, sourceId, moduleId, Storage::Synchronization::FileType::QmlTypes};
moduleId,
Storage::Synchronization::FileType::QmlTypes};
FileState state = parseTypeInfo(projectData, FileState state = parseTypeInfo(directoryInfo,
Utils::PathString{qmlTypesPath}, Utils::PathString{qmlTypesPath},
package, package,
notUpdatedSourceIds); notUpdatedSourceIds);
if (state == FileState::Changed) { if (state == FileState::Changed) {
tracer.tick("append project data"_t, keyValue("project data", projectData)); tracer.tick("append project data"_t, keyValue("project data", directoryInfo));
package.projectDatas.push_back(std::move(projectData)); package.directoryInfos.push_back(std::move(directoryInfo));
tracer.tick("append updated project source ids"_t, keyValue("source id", sourceId)); tracer.tick("append updated project source ids"_t, keyValue("source id", sourceId));
package.updatedProjectSourceIds.push_back(sourceId); package.updatedProjectSourceIds.push_back(sourceId);
} }
@@ -382,10 +380,10 @@ void ProjectStorageUpdater::updateDirectoryChanged(std::string_view directoryPat
tracer.tick("append updated module id"_t, keyValue("module id", moduleId)); tracer.tick("append updated module id"_t, keyValue("module id", moduleId));
package.updatedModuleIds.push_back(moduleId); package.updatedModuleIds.push_back(moduleId);
const auto qmlProjectDatas = m_projectStorage.fetchProjectDatas(directorySourceId); const auto qmlDirectoryInfos = m_projectStorage.fetchDirectoryInfos(directorySourceId);
addSourceIds(package.updatedSourceIds, qmlProjectDatas, "append updated source id"_t, tracer); addSourceIds(package.updatedSourceIds, qmlDirectoryInfos, "append updated source id"_t, tracer);
addSourceIds(package.updatedFileStatusSourceIds, addSourceIds(package.updatedFileStatusSourceIds,
qmlProjectDatas, qmlDirectoryInfos,
"append updated file status source id"_t, "append updated file status source id"_t,
tracer); tracer);
@@ -463,10 +461,10 @@ void ProjectStorageUpdater::updateDirectory(const Utils::PathString &directoryPa
case FileState::NotChanged: { case FileState::NotChanged: {
tracer.tick("update directory not changed"_t); tracer.tick("update directory not changed"_t);
parseProjectDatas(m_projectStorage.fetchProjectDatas(directorySourceId), parseDirectoryInfos(m_projectStorage.fetchDirectoryInfos(directorySourceId),
package, package,
notUpdatedSourceIds, notUpdatedSourceIds,
watchedSourceIdsIds); watchedSourceIdsIds);
break; break;
} }
case FileState::NotExists: { case FileState::NotExists: {
@@ -476,13 +474,13 @@ void ProjectStorageUpdater::updateDirectory(const Utils::PathString &directoryPa
package.updatedFileStatusSourceIds.push_back(qmldirSourceId); package.updatedFileStatusSourceIds.push_back(qmldirSourceId);
package.updatedProjectSourceIds.push_back(directorySourceId); package.updatedProjectSourceIds.push_back(directorySourceId);
package.updatedSourceIds.push_back(qmldirSourceId); package.updatedSourceIds.push_back(qmldirSourceId);
auto qmlProjectDatas = m_projectStorage.fetchProjectDatas(directorySourceId); auto qmlDirectoryInfos = m_projectStorage.fetchDirectoryInfos(directorySourceId);
for (const Storage::Synchronization::ProjectData &projectData : qmlProjectDatas) { for (const Storage::Synchronization::DirectoryInfo &directoryInfo : qmlDirectoryInfos) {
tracer.tick("append updated source id"_t, keyValue("source id", projectData.sourceId)); tracer.tick("append updated source id"_t, keyValue("source id", directoryInfo.sourceId));
package.updatedSourceIds.push_back(projectData.sourceId); package.updatedSourceIds.push_back(directoryInfo.sourceId);
tracer.tick("append updated file status source id"_t, tracer.tick("append updated file status source id"_t,
keyValue("source id", projectData.sourceId)); keyValue("source id", directoryInfo.sourceId));
package.updatedFileStatusSourceIds.push_back(projectData.sourceId); package.updatedFileStatusSourceIds.push_back(directoryInfo.sourceId);
} }
break; break;
@@ -802,9 +800,9 @@ void ProjectStorageUpdater::pathsWithIdsChanged(const std::vector<IdPaths> &chan
for (SourceId sourceId : filterUniqueSourceIds(std::move(qmltypesSourceIds))) { for (SourceId sourceId : filterUniqueSourceIds(std::move(qmltypesSourceIds))) {
if (!contains(directorySourceContextIds, m_pathCache.sourceContextId(sourceId))) { if (!contains(directorySourceContextIds, m_pathCache.sourceContextId(sourceId))) {
auto qmltypesPath = m_pathCache.sourcePath(sourceId); auto qmltypesPath = m_pathCache.sourcePath(sourceId);
auto projectData = m_projectStorage.fetchProjectData(sourceId); auto directoryInfo = m_projectStorage.fetchDirectoryInfo(sourceId);
if (projectData) if (directoryInfo)
parseTypeInfo(*projectData, qmltypesPath, package, notUpdatedSourceIds); parseTypeInfo(*directoryInfo, qmltypesPath, package, notUpdatedSourceIds);
} }
} }
} catch (const QmlDesigner::CannotParseQmlTypesFile &) { } catch (const QmlDesigner::CannotParseQmlTypesFile &) {
@@ -869,41 +867,42 @@ void ProjectStorageUpdater::parseTypeInfos(const QStringList &typeInfos,
tracer.tick("append module dependenct source source id"_t, keyValue("source id", sourceId)); tracer.tick("append module dependenct source source id"_t, keyValue("source id", sourceId));
package.updatedModuleDependencySourceIds.push_back(sourceId); package.updatedModuleDependencySourceIds.push_back(sourceId);
auto projectData = package.projectDatas.emplace_back( auto directoryInfo = package.directoryInfos.emplace_back(
directorySourceId, sourceId, moduleId, Storage::Synchronization::FileType::QmlTypes); directorySourceId, sourceId, moduleId, Storage::Synchronization::FileType::QmlTypes);
tracer.tick("append project data"_t, keyValue("source id", sourceId)); tracer.tick("append project data"_t, keyValue("source id", sourceId));
parseTypeInfo(projectData, qmltypesPath, package, notUpdatedSourceIds); parseTypeInfo(directoryInfo, qmltypesPath, package, notUpdatedSourceIds);
} }
} }
void ProjectStorageUpdater::parseProjectDatas(const Storage::Synchronization::ProjectDatas &projectDatas, void ProjectStorageUpdater::parseDirectoryInfos(
Storage::Synchronization::SynchronizationPackage &package, const Storage::Synchronization::DirectoryInfos &directoryInfos,
NotUpdatedSourceIds &notUpdatedSourceIds, Storage::Synchronization::SynchronizationPackage &package,
WatchedSourceIdsIds &watchedSourceIds) NotUpdatedSourceIds &notUpdatedSourceIds,
WatchedSourceIdsIds &watchedSourceIds)
{ {
NanotraceHR::Tracer tracer{"parse project datas"_t, category()}; NanotraceHR::Tracer tracer{"parse project datas"_t, category()};
for (const Storage::Synchronization::ProjectData &projectData : projectDatas) { for (const Storage::Synchronization::DirectoryInfo &directoryInfo : directoryInfos) {
switch (projectData.fileType) { switch (directoryInfo.fileType) {
case Storage::Synchronization::FileType::QmlTypes: { case Storage::Synchronization::FileType::QmlTypes: {
watchedSourceIds.qmltypesSourceIds.push_back(projectData.sourceId); watchedSourceIds.qmltypesSourceIds.push_back(directoryInfo.sourceId);
auto qmltypesPath = m_pathCache.sourcePath(projectData.sourceId); auto qmltypesPath = m_pathCache.sourcePath(directoryInfo.sourceId);
parseTypeInfo(projectData, qmltypesPath, package, notUpdatedSourceIds); parseTypeInfo(directoryInfo, qmltypesPath, package, notUpdatedSourceIds);
break; break;
} }
case Storage::Synchronization::FileType::QmlDocument: { case Storage::Synchronization::FileType::QmlDocument: {
watchedSourceIds.qmlSourceIds.push_back(projectData.sourceId); watchedSourceIds.qmlSourceIds.push_back(directoryInfo.sourceId);
parseQmlComponent(projectData.sourceId, package, notUpdatedSourceIds); parseQmlComponent(directoryInfo.sourceId, package, notUpdatedSourceIds);
break; break;
} }
} }
} }
} }
auto ProjectStorageUpdater::parseTypeInfo(const Storage::Synchronization::ProjectData &projectData, auto ProjectStorageUpdater::parseTypeInfo(const Storage::Synchronization::DirectoryInfo &directoryInfo,
Utils::SmallStringView qmltypesPath, Utils::SmallStringView qmltypesPath,
Storage::Synchronization::SynchronizationPackage &package, Storage::Synchronization::SynchronizationPackage &package,
NotUpdatedSourceIds &notUpdatedSourceIds) -> FileState NotUpdatedSourceIds &notUpdatedSourceIds) -> FileState
@@ -912,19 +911,19 @@ auto ProjectStorageUpdater::parseTypeInfo(const Storage::Synchronization::Projec
category(), category(),
keyValue("qmltypes path", qmltypesPath)}; keyValue("qmltypes path", qmltypesPath)};
auto state = fileState(projectData.sourceId, package, notUpdatedSourceIds); auto state = fileState(directoryInfo.sourceId, package, notUpdatedSourceIds);
switch (state) { switch (state) {
case FileState::Changed: { case FileState::Changed: {
tracer.tick("append updated source ids"_t, keyValue("source id", projectData.sourceId)); tracer.tick("append updated source ids"_t, keyValue("source id", directoryInfo.sourceId));
package.updatedSourceIds.push_back(projectData.sourceId); package.updatedSourceIds.push_back(directoryInfo.sourceId);
const auto content = m_fileSystem.contentAsQString(QString{qmltypesPath}); const auto content = m_fileSystem.contentAsQString(QString{qmltypesPath});
m_qmlTypesParser.parse(content, package.imports, package.types, projectData); m_qmlTypesParser.parse(content, package.imports, package.types, directoryInfo);
break; break;
} }
case FileState::NotChanged: { case FileState::NotChanged: {
tracer.tick("append not updated source ids"_t, keyValue("source id", projectData.sourceId)); tracer.tick("append not updated source ids"_t, keyValue("source id", directoryInfo.sourceId));
notUpdatedSourceIds.sourceIds.push_back(projectData.sourceId); notUpdatedSourceIds.sourceIds.push_back(directoryInfo.sourceId);
break; break;
} }
case FileState::NotExists: case FileState::NotExists:
@@ -971,9 +970,9 @@ void ProjectStorageUpdater::parseQmlComponent(Utils::SmallStringView relativeFil
tracer.tick("append not updated source id"_t, keyValue("source id", sourceId)); tracer.tick("append not updated source id"_t, keyValue("source id", sourceId));
notUpdatedSourceIds.sourceIds.emplace_back(sourceId); notUpdatedSourceIds.sourceIds.emplace_back(sourceId);
const auto &projectData = package.projectDatas.emplace_back( const auto &directoryInfo = package.directoryInfos.emplace_back(
directorySourceId, sourceId, ModuleId{}, Storage::Synchronization::FileType::QmlDocument); directorySourceId, sourceId, ModuleId{}, Storage::Synchronization::FileType::QmlDocument);
tracer.tick("append project data"_t, keyValue("project data", projectData)); tracer.tick("append project data"_t, keyValue("project data", directoryInfo));
return; return;
} }
@@ -987,9 +986,9 @@ void ProjectStorageUpdater::parseQmlComponent(Utils::SmallStringView relativeFil
break; break;
} }
const auto &projectData = package.projectDatas.emplace_back( const auto &directoryInfo = package.directoryInfos.emplace_back(
directorySourceId, sourceId, ModuleId{}, Storage::Synchronization::FileType::QmlDocument); directorySourceId, sourceId, ModuleId{}, Storage::Synchronization::FileType::QmlDocument);
tracer.tick("append project data"_t, keyValue("project data", projectData)); tracer.tick("append project data"_t, keyValue("project data", directoryInfo));
tracer.tick("append updated source id"_t, keyValue("source id", sourceId)); tracer.tick("append updated source id"_t, keyValue("source id", sourceId));
package.updatedSourceIds.push_back(sourceId); package.updatedSourceIds.push_back(sourceId);

10
src/plugins/qmldesigner/designercore/projectstorage/projectstorageupdater.h
View File

@@ -192,11 +192,11 @@ private:
Storage::Synchronization::SynchronizationPackage &package, Storage::Synchronization::SynchronizationPackage &package,
NotUpdatedSourceIds &notUpdatedSourceIds, NotUpdatedSourceIds &notUpdatedSourceIds,
WatchedSourceIdsIds &watchedSourceIdsIds); WatchedSourceIdsIds &watchedSourceIdsIds);
void parseProjectDatas(const Storage::Synchronization::ProjectDatas &projectDatas, void parseDirectoryInfos(const Storage::Synchronization::DirectoryInfos &directoryInfos,
Storage::Synchronization::SynchronizationPackage &package, Storage::Synchronization::SynchronizationPackage &package,
NotUpdatedSourceIds &notUpdatedSourceIds, NotUpdatedSourceIds &notUpdatedSourceIds,
WatchedSourceIdsIds &watchedSourceIdsIds); WatchedSourceIdsIds &watchedSourceIdsIds);
FileState parseTypeInfo(const Storage::Synchronization::ProjectData &projectData, FileState parseTypeInfo(const Storage::Synchronization::DirectoryInfo &directoryInfo,
Utils::SmallStringView qmltypesPath, Utils::SmallStringView qmltypesPath,
Storage::Synchronization::SynchronizationPackage &package, Storage::Synchronization::SynchronizationPackage &package,
NotUpdatedSourceIds &notUpdatedSourceIds); NotUpdatedSourceIds &notUpdatedSourceIds);

16
src/plugins/qmldesigner/designercore/projectstorage/qmltypesparser.cpp
View File

@@ -495,7 +495,7 @@ bool skipType(const QQmlJSExportedScope &object, Utils::span<const QLatin1String
} }
void addTypes(Storage::Synchronization::Types &types, void addTypes(Storage::Synchronization::Types &types,
const Storage::Synchronization::ProjectData &projectData, const Storage::Synchronization::DirectoryInfo &directoryInfo,
const QList<QQmlJSExportedScope> &objects, const QList<QQmlJSExportedScope> &objects,
QmlTypesParser::ProjectStorage &storage, QmlTypesParser::ProjectStorage &storage,
const ComponentWithoutNamespaces &componentNameWithoutNamespaces) const ComponentWithoutNamespaces &componentNameWithoutNamespaces)
@@ -503,15 +503,15 @@ void addTypes(Storage::Synchronization::Types &types,
NanotraceHR::Tracer tracer{"add types"_t, category()}; NanotraceHR::Tracer tracer{"add types"_t, category()};
types.reserve(Utils::usize(objects) + types.size()); types.reserve(Utils::usize(objects) + types.size());
const auto skipList = getSkipList(storage.module(projectData.moduleId)); const auto skipList = getSkipList(storage.module(directoryInfo.moduleId));
for (const auto &object : objects) { for (const auto &object : objects) {
if (skipType(object, skipList)) if (skipType(object, skipList))
continue; continue;
addType(types, addType(types,
projectData.sourceId, directoryInfo.sourceId,
projectData.moduleId, directoryInfo.moduleId,
object, object,
storage, storage,
componentNameWithoutNamespaces); componentNameWithoutNamespaces);
@@ -523,7 +523,7 @@ void addTypes(Storage::Synchronization::Types &types,
void QmlTypesParser::parse(const QString &sourceContent, void QmlTypesParser::parse(const QString &sourceContent,
Storage::Imports &imports, Storage::Imports &imports,
Storage::Synchronization::Types &types, Storage::Synchronization::Types &types,
const Storage::Synchronization::ProjectData &projectData) const Storage::Synchronization::DirectoryInfo &directoryInfo)
{ {
NanotraceHR::Tracer tracer{"qmltypes parser parse"_t, category()}; NanotraceHR::Tracer tracer{"qmltypes parser parse"_t, category()};
@@ -536,8 +536,8 @@ void QmlTypesParser::parse(const QString &sourceContent,
auto componentNameWithoutNamespaces = createComponentNameWithoutNamespaces(components); auto componentNameWithoutNamespaces = createComponentNameWithoutNamespaces(components);
addImports(imports, projectData.sourceId, dependencies, m_storage, projectData.moduleId); addImports(imports, directoryInfo.sourceId, dependencies, m_storage, directoryInfo.moduleId);
addTypes(types, projectData, components, m_storage, componentNameWithoutNamespaces); addTypes(types, directoryInfo, components, m_storage, componentNameWithoutNamespaces);
} }
#else #else
@@ -545,7 +545,7 @@ void QmlTypesParser::parse(const QString &sourceContent,
void QmlTypesParser::parse([[maybe_unused]] const QString &sourceContent, void QmlTypesParser::parse([[maybe_unused]] const QString &sourceContent,
[[maybe_unused]] Storage::Imports &imports, [[maybe_unused]] Storage::Imports &imports,
[[maybe_unused]] Storage::Synchronization::Types &types, [[maybe_unused]] Storage::Synchronization::Types &types,
[[maybe_unused]] const Storage::Synchronization::ProjectData &projectData) [[maybe_unused]] const Storage::Synchronization::DirectoryInfo &directoryInfo)
{} {}
#endif #endif

2
src/plugins/qmldesigner/designercore/projectstorage/qmltypesparser.h
View File

@@ -31,7 +31,7 @@ public:
void parse(const QString &sourceContent, void parse(const QString &sourceContent,
Storage::Imports &imports, Storage::Imports &imports,
Storage::Synchronization::Types &types, Storage::Synchronization::Types &types,
const Storage::Synchronization::ProjectData &projectData) override; const Storage::Synchronization::DirectoryInfo &directoryInfo) override;
private: private:
#ifdef QDS_BUILD_QMLPARSER #ifdef QDS_BUILD_QMLPARSER

2
src/plugins/qmldesigner/designercore/projectstorage/qmltypesparserinterface.h
View File

@@ -15,7 +15,7 @@ public:
virtual void parse(const QString &sourceContent, virtual void parse(const QString &sourceContent,
Storage::Imports &imports, Storage::Imports &imports,
Storage::Synchronization::Types &types, Storage::Synchronization::Types &types,
const Storage::Synchronization::ProjectData &projectData) const Storage::Synchronization::DirectoryInfo &directoryInfo)
= 0; = 0;
protected: protected:

38
src/plugins/qmldesigner/qmldesignerprojectmanager.cpp
View File

@@ -210,10 +210,10 @@ std::unique_ptr<ProjectStorageData> createProjectStorageData(::ProjectExplorer::
} }
} // namespace } // namespace
class QmlDesignerProjectManager::QmlDesignerProjectManagerProjectData class QmlDesignerProjectManager::QmlDesignerProjectManagerDirectoryInfo
{ {
public: public:
QmlDesignerProjectManagerProjectData(ImageCacheStorage<Sqlite::Database> &storage, QmlDesignerProjectManagerDirectoryInfo(ImageCacheStorage<Sqlite::Database> &storage,
::ProjectExplorer::Project *project, ::ProjectExplorer::Project *project,
ExternalDependenciesInterface &externalDependencies) ExternalDependenciesInterface &externalDependencies)
: collector{connectionManager, : collector{connectionManager,
@@ -297,8 +297,8 @@ namespace {
ProjectStorageDependencies QmlDesignerProjectManager::projectStorageDependencies() ProjectStorageDependencies QmlDesignerProjectManager::projectStorageDependencies()
{ {
if constexpr (useProjectStorage()) { if constexpr (useProjectStorage()) {
return {m_projectData->projectStorageData->storage, return {m_directoryInfo->projectStorageData->storage,
m_projectData->projectStorageData->pathCache}; m_directoryInfo->projectStorageData->pathCache};
} else { } else {
return {*dummyProjectStorage(), *dummyPathCache()}; return {*dummyProjectStorage(), *dummyPathCache()};
} }
@@ -499,10 +499,10 @@ QString qtCreatorItemLibraryPath()
void QmlDesignerProjectManager::projectAdded(::ProjectExplorer::Project *project) void QmlDesignerProjectManager::projectAdded(::ProjectExplorer::Project *project)
{ {
m_projectData = std::make_unique<QmlDesignerProjectManagerProjectData>(m_previewImageCacheData->storage, m_directoryInfo = std::make_unique<QmlDesignerProjectManagerDirectoryInfo>(m_previewImageCacheData->storage,
project, project,
m_externalDependencies); m_externalDependencies);
m_projectData->activeTarget = project->activeTarget(); m_directoryInfo->activeTarget = project->activeTarget();
QObject::connect(project, &::ProjectExplorer::Project::fileListChanged, [&]() { QObject::connect(project, &::ProjectExplorer::Project::fileListChanged, [&]() {
fileListChanged(); fileListChanged();
@@ -522,9 +522,9 @@ void QmlDesignerProjectManager::projectAdded(::ProjectExplorer::Project *project
void QmlDesignerProjectManager::aboutToRemoveProject(::ProjectExplorer::Project *) void QmlDesignerProjectManager::aboutToRemoveProject(::ProjectExplorer::Project *)
{ {
if (m_projectData) { if (m_directoryInfo) {
m_previewImageCacheData->collector.setTarget(m_projectData->activeTarget); m_previewImageCacheData->collector.setTarget(m_directoryInfo->activeTarget);
m_projectData.reset(); m_directoryInfo.reset();
} }
} }
@@ -532,14 +532,14 @@ void QmlDesignerProjectManager::projectRemoved(::ProjectExplorer::Project *) {}
void QmlDesignerProjectManager::generatePreview() void QmlDesignerProjectManager::generatePreview()
{ {
if (!m_projectData || !m_projectData->activeTarget) if (!m_directoryInfo || !m_directoryInfo->activeTarget)
return; return;
::QmlProjectManager::QmlBuildSystem *qmlBuildSystem = getQmlBuildSystem( ::QmlProjectManager::QmlBuildSystem *qmlBuildSystem = getQmlBuildSystem(
m_projectData->activeTarget); m_directoryInfo->activeTarget);
if (qmlBuildSystem) { if (qmlBuildSystem) {
m_previewImageCacheData->collector.setTarget(m_projectData->activeTarget); m_previewImageCacheData->collector.setTarget(m_directoryInfo->activeTarget);
m_previewImageCacheData->factory.generate(qmlBuildSystem->mainFilePath().toString().toUtf8()); m_previewImageCacheData->factory.generate(qmlBuildSystem->mainFilePath().toString().toUtf8());
} }
} }
@@ -587,12 +587,12 @@ void QmlDesignerProjectManager::fileListChanged()
void QmlDesignerProjectManager::activeTargetChanged(ProjectExplorer::Target *target) void QmlDesignerProjectManager::activeTargetChanged(ProjectExplorer::Target *target)
{ {
if (!m_projectData || !m_projectData->projectStorageData) if (!m_directoryInfo || !m_directoryInfo->projectStorageData)
return; return;
QObject::disconnect(m_projectData->activeTarget, nullptr, nullptr, nullptr); QObject::disconnect(m_directoryInfo->activeTarget, nullptr, nullptr, nullptr);
m_projectData->activeTarget = target; m_directoryInfo->activeTarget = target;
if (target) { if (target) {
QObject::connect(target, &::ProjectExplorer::Target::kitChanged, [&]() { kitChanged(); }); QObject::connect(target, &::ProjectExplorer::Target::kitChanged, [&]() { kitChanged(); });
@@ -625,17 +625,17 @@ void QmlDesignerProjectManager::projectChanged()
void QmlDesignerProjectManager::update() void QmlDesignerProjectManager::update()
{ {
if (!m_projectData || !m_projectData->projectStorageData) if (!m_directoryInfo || !m_directoryInfo->projectStorageData)
return; return;
if constexpr (isUsingQmlDesignerLite()) { if constexpr (isUsingQmlDesignerLite()) {
m_projectData->projectStorageData->updater.update(directoriesForLiteDesigner(), m_directoryInfo->projectStorageData->updater.update(directoriesForLiteDesigner(),
qmlTypesForLiteDesigner(), qmlTypesForLiteDesigner(),
propertyEditorResourcesPath(), propertyEditorResourcesPath(),
{qtCreatorItemLibraryPath()}); {qtCreatorItemLibraryPath()});
} else { } else {
m_projectData->projectStorageData->updater.update(directories(m_projectData->activeTarget), m_directoryInfo->projectStorageData->updater.update(directories(m_directoryInfo->activeTarget),
qmlTypes(m_projectData->activeTarget), qmlTypes(m_directoryInfo->activeTarget),
propertyEditorResourcesPath(), propertyEditorResourcesPath(),
{qtCreatorItemLibraryPath()}); {qtCreatorItemLibraryPath()});
} }

4
src/plugins/qmldesigner/qmldesignerprojectmanager.h
View File

@@ -32,7 +32,7 @@ class QmlDesignerProjectManager : public QObject
{ {
Q_OBJECT Q_OBJECT
class QmlDesignerProjectManagerProjectData; class QmlDesignerProjectManagerDirectoryInfo;
class PreviewImageCacheData; class PreviewImageCacheData;
class ImageCacheData; class ImageCacheData;
@@ -68,7 +68,7 @@ private:
std::once_flag imageCacheFlag; std::once_flag imageCacheFlag;
std::unique_ptr<ImageCacheData> m_imageCacheData; std::unique_ptr<ImageCacheData> m_imageCacheData;
std::unique_ptr<PreviewImageCacheData> m_previewImageCacheData; std::unique_ptr<PreviewImageCacheData> m_previewImageCacheData;
std::unique_ptr<QmlDesignerProjectManagerProjectData> m_projectData; std::unique_ptr<QmlDesignerProjectManagerDirectoryInfo> m_directoryInfo;
ExternalDependenciesInterface &m_externalDependencies; ExternalDependenciesInterface &m_externalDependencies;
}; };
} // namespace QmlDesigner } // namespace QmlDesigner

8
tests/unit/tests/mocks/projectstoragemock.h
View File

@@ -300,13 +300,13 @@ public:
(QmlDesigner::SourceId sourceId), (QmlDesigner::SourceId sourceId),
(const, override)); (const, override));
MOCK_METHOD(QmlDesigner::Storage::Synchronization::ProjectDatas, MOCK_METHOD(QmlDesigner::Storage::Synchronization::DirectoryInfos,
fetchProjectDatas, fetchDirectoryInfos,
(QmlDesigner::SourceId sourceId), (QmlDesigner::SourceId sourceId),
(const, override)); (const, override));
MOCK_METHOD(std::optional<QmlDesigner::Storage::Synchronization::ProjectData>, MOCK_METHOD(std::optional<QmlDesigner::Storage::Synchronization::DirectoryInfo>,
fetchProjectData, fetchDirectoryInfo,
(QmlDesigner::SourceId sourceId), (QmlDesigner::SourceId sourceId),
(const, override)); (const, override));

2
tests/unit/tests/mocks/qmltypesparsermock.h
View File

@@ -15,6 +15,6 @@ public:
(const QString &sourceContent, (const QString &sourceContent,
QmlDesigner::Storage::Imports &imports, QmlDesigner::Storage::Imports &imports,
QmlDesigner::Storage::Synchronization::Types &types, QmlDesigner::Storage::Synchronization::Types &types,
const QmlDesigner::Storage::Synchronization::ProjectData &projectData), const QmlDesigner::Storage::Synchronization::DirectoryInfo &directoryInfo),
(override)); (override));
}; };

6
tests/unit/tests/printers/gtest-creator-printing.cpp
View File

@@ -792,7 +792,7 @@ std::ostream &operator<<(std::ostream &out, const SynchronizationPackage &packag
<< ", fileStatuses: " << package.fileStatuses << ", fileStatuses: " << package.fileStatuses
<< ", updatedFileStatusSourceIds: " << package.updatedFileStatusSourceIds << ", updatedFileStatusSourceIds: " << package.updatedFileStatusSourceIds
<< ", updatedProjectSourceIds: " << package.updatedProjectSourceIds << ", updatedProjectSourceIds: " << package.updatedProjectSourceIds
<< ", projectDatas: " << package.projectDatas << ", directoryInfos: " << package.directoryInfos
<< ", propertyEditorQmlPaths: " << package.propertyEditorQmlPaths << ", propertyEditorQmlPaths: " << package.propertyEditorQmlPaths
<< ", updatedPropertyEditorQmlPathSourceIds: " << ", updatedPropertyEditorQmlPathSourceIds: "
<< package.updatedPropertyEditorQmlPathSourceIds << package.updatedPropertyEditorQmlPathSourceIds
@@ -801,9 +801,9 @@ std::ostream &operator<<(std::ostream &out, const SynchronizationPackage &packag
<< ")"; << ")";
} }
std::ostream &operator<<(std::ostream &out, const ProjectData &data) std::ostream &operator<<(std::ostream &out, const DirectoryInfo &data)
{ {
return out << "(" << data.projectSourceId << ", " << data.sourceId << ", " << data.moduleId return out << "(" << data.directorySourceId << ", " << data.sourceId << ", " << data.moduleId
<< ", " << data.fileType << ")"; << ", " << data.fileType << ")";
} }

4
tests/unit/tests/printers/gtest-creator-printing.h
View File

@@ -207,7 +207,7 @@ class EnumeratorDeclaration;
enum class ImportKind : char; enum class ImportKind : char;
enum class IsAutoVersion : char; enum class IsAutoVersion : char;
enum class IsQualified : int; enum class IsQualified : int;
class ProjectData; class DirectoryInfo;
class SynchronizationPackage; class SynchronizationPackage;
enum class FileType : char; enum class FileType : char;
enum class ChangeLevel : char; enum class ChangeLevel : char;
@@ -227,7 +227,7 @@ std::ostream &operator<<(std::ostream &out, const EnumerationDeclaration &enumer
std::ostream &operator<<(std::ostream &out, const EnumeratorDeclaration &enumeratorDeclaration); std::ostream &operator<<(std::ostream &out, const EnumeratorDeclaration &enumeratorDeclaration);
std::ostream &operator<<(std::ostream &out, const ImportKind &importKind); std::ostream &operator<<(std::ostream &out, const ImportKind &importKind);
std::ostream &operator<<(std::ostream &out, IsQualified isQualified); std::ostream &operator<<(std::ostream &out, IsQualified isQualified);
std::ostream &operator<<(std::ostream &out, const ProjectData &data); std::ostream &operator<<(std::ostream &out, const DirectoryInfo &data);
std::ostream &operator<<(std::ostream &out, const SynchronizationPackage &package); std::ostream &operator<<(std::ostream &out, const SynchronizationPackage &package);
std::ostream &operator<<(std::ostream &out, FileType fileType); std::ostream &operator<<(std::ostream &out, FileType fileType);
std::ostream &operator<<(std::ostream &out, ChangeLevel changeLevel); std::ostream &operator<<(std::ostream &out, ChangeLevel changeLevel);

148
tests/unit/tests/unittests/projectstorage/projectstorage-test.cpp
View File

@@ -5123,220 +5123,220 @@ TEST_F(ProjectStorage, populate_module_cache)
ASSERT_THAT(newStorage.module(id), IsModule("Qml", ModuleKind::QmlLibrary)); ASSERT_THAT(newStorage.module(id), IsModule("Qml", ModuleKind::QmlLibrary));
} }
TEST_F(ProjectStorage, add_project_dataes) TEST_F(ProjectStorage, add_directory_infoes)
{ {
Storage::Synchronization::ProjectData projectData1{qmlProjectSourceId, Storage::Synchronization::DirectoryInfo directoryInfo1{qmlProjectSourceId,
sourceId1, sourceId1,
qmlModuleId, qmlModuleId,
Storage::Synchronization::FileType::QmlDocument}; Storage::Synchronization::FileType::QmlDocument};
Storage::Synchronization::ProjectData projectData2{qmlProjectSourceId, Storage::Synchronization::DirectoryInfo directoryInfo2{qmlProjectSourceId,
sourceId2, sourceId2,
qmlModuleId, qmlModuleId,
Storage::Synchronization::FileType::QmlDocument}; Storage::Synchronization::FileType::QmlDocument};
Storage::Synchronization::ProjectData projectData3{qtQuickProjectSourceId, Storage::Synchronization::DirectoryInfo directoryInfo3{qtQuickProjectSourceId,
sourceId3, sourceId3,
qtQuickModuleId, qtQuickModuleId,
Storage::Synchronization::FileType::QmlTypes}; Storage::Synchronization::FileType::QmlTypes};
storage.synchronize(SynchronizationPackage{{qmlProjectSourceId, qtQuickProjectSourceId}, storage.synchronize(SynchronizationPackage{{qmlProjectSourceId, qtQuickProjectSourceId},
{projectData1, projectData2, projectData3}}); {directoryInfo1, directoryInfo2, directoryInfo3}});
ASSERT_THAT(storage.fetchProjectDatas({qmlProjectSourceId, qtQuickProjectSourceId}), ASSERT_THAT(storage.fetchDirectoryInfos({qmlProjectSourceId, qtQuickProjectSourceId}),
UnorderedElementsAre(projectData1, projectData2, projectData3)); UnorderedElementsAre(directoryInfo1, directoryInfo2, directoryInfo3));
} }
TEST_F(ProjectStorage, remove_project_data) TEST_F(ProjectStorage, remove_directory_info)
{ {
Storage::Synchronization::ProjectData projectData1{qmlProjectSourceId, Storage::Synchronization::DirectoryInfo directoryInfo1{qmlProjectSourceId,
sourceId1, sourceId1,
qmlModuleId, qmlModuleId,
Storage::Synchronization::FileType::QmlDocument}; Storage::Synchronization::FileType::QmlDocument};
Storage::Synchronization::ProjectData projectData2{qmlProjectSourceId, Storage::Synchronization::DirectoryInfo directoryInfo2{qmlProjectSourceId,
sourceId2, sourceId2,
qmlModuleId, qmlModuleId,
Storage::Synchronization::FileType::QmlDocument}; Storage::Synchronization::FileType::QmlDocument};
Storage::Synchronization::ProjectData projectData3{qtQuickProjectSourceId, Storage::Synchronization::DirectoryInfo directoryInfo3{qtQuickProjectSourceId,
sourceId3, sourceId3,
qtQuickModuleId, qtQuickModuleId,
Storage::Synchronization::FileType::QmlTypes}; Storage::Synchronization::FileType::QmlTypes};
storage.synchronize(SynchronizationPackage{{qmlProjectSourceId, qtQuickProjectSourceId}, storage.synchronize(SynchronizationPackage{{qmlProjectSourceId, qtQuickProjectSourceId},
{projectData1, projectData2, projectData3}}); {directoryInfo1, directoryInfo2, directoryInfo3}});
storage.synchronize( storage.synchronize(
SynchronizationPackage{{qmlProjectSourceId, qtQuickProjectSourceId}, {projectData1}}); SynchronizationPackage{{qmlProjectSourceId, qtQuickProjectSourceId}, {directoryInfo1}});
ASSERT_THAT(storage.fetchProjectDatas({qmlProjectSourceId, qtQuickProjectSourceId}), ASSERT_THAT(storage.fetchDirectoryInfos({qmlProjectSourceId, qtQuickProjectSourceId}),
UnorderedElementsAre(projectData1)); UnorderedElementsAre(directoryInfo1));
} }
TEST_F(ProjectStorage, update_project_data_file_type) TEST_F(ProjectStorage, update_directory_info_file_type)
{ {
Storage::Synchronization::ProjectData projectData1{qmlProjectSourceId, Storage::Synchronization::DirectoryInfo directoryInfo1{qmlProjectSourceId,
sourceId1, sourceId1,
qmlModuleId, qmlModuleId,
Storage::Synchronization::FileType::QmlDocument}; Storage::Synchronization::FileType::QmlDocument};
Storage::Synchronization::ProjectData projectData2{qmlProjectSourceId, Storage::Synchronization::DirectoryInfo directoryInfo2{qmlProjectSourceId,
sourceId2, sourceId2,
qmlModuleId, qmlModuleId,
Storage::Synchronization::FileType::QmlDocument}; Storage::Synchronization::FileType::QmlDocument};
Storage::Synchronization::ProjectData projectData2b{qmlProjectSourceId, Storage::Synchronization::DirectoryInfo directoryInfo2b{qmlProjectSourceId,
sourceId2, sourceId2,
qmlModuleId, qmlModuleId,
Storage::Synchronization::FileType::QmlTypes}; Storage::Synchronization::FileType::QmlTypes};
Storage::Synchronization::ProjectData projectData3{qtQuickProjectSourceId, Storage::Synchronization::DirectoryInfo directoryInfo3{qtQuickProjectSourceId,
sourceId3, sourceId3,
qtQuickModuleId, qtQuickModuleId,
Storage::Synchronization::FileType::QmlTypes}; Storage::Synchronization::FileType::QmlTypes};
storage.synchronize(SynchronizationPackage{{qmlProjectSourceId, qtQuickProjectSourceId}, storage.synchronize(SynchronizationPackage{{qmlProjectSourceId, qtQuickProjectSourceId},
{projectData1, projectData2, projectData3}}); {directoryInfo1, directoryInfo2, directoryInfo3}});
storage.synchronize(SynchronizationPackage{{qmlProjectSourceId}, {projectData1, projectData2b}}); storage.synchronize(SynchronizationPackage{{qmlProjectSourceId}, {directoryInfo1, directoryInfo2b}});
ASSERT_THAT(storage.fetchProjectDatas({qmlProjectSourceId, qtQuickProjectSourceId}), ASSERT_THAT(storage.fetchDirectoryInfos({qmlProjectSourceId, qtQuickProjectSourceId}),
UnorderedElementsAre(projectData1, projectData2b, projectData3)); UnorderedElementsAre(directoryInfo1, directoryInfo2b, directoryInfo3));
} }
TEST_F(ProjectStorage, update_project_data_module_id) TEST_F(ProjectStorage, update_directory_info_module_id)
{ {
Storage::Synchronization::ProjectData projectData1{qmlProjectSourceId, Storage::Synchronization::DirectoryInfo directoryInfo1{qmlProjectSourceId,
sourceId1, sourceId1,
qmlModuleId, qmlModuleId,
Storage::Synchronization::FileType::QmlDocument}; Storage::Synchronization::FileType::QmlDocument};
Storage::Synchronization::ProjectData projectData2{qmlProjectSourceId, Storage::Synchronization::DirectoryInfo directoryInfo2{qmlProjectSourceId,
sourceId3, sourceId3,
qmlModuleId, qmlModuleId,
Storage::Synchronization::FileType::QmlDocument}; Storage::Synchronization::FileType::QmlDocument};
Storage::Synchronization::ProjectData projectData2b{qmlProjectSourceId, Storage::Synchronization::DirectoryInfo directoryInfo2b{qmlProjectSourceId,
sourceId3, sourceId3,
qtQuickModuleId, qtQuickModuleId,
Storage::Synchronization::FileType::QmlDocument}; Storage::Synchronization::FileType::QmlDocument};
Storage::Synchronization::ProjectData projectData3{qtQuickProjectSourceId, Storage::Synchronization::DirectoryInfo directoryInfo3{qtQuickProjectSourceId,
sourceId2, sourceId2,
qtQuickModuleId, qtQuickModuleId,
Storage::Synchronization::FileType::QmlTypes}; Storage::Synchronization::FileType::QmlTypes};
storage.synchronize(SynchronizationPackage{{qmlProjectSourceId, qtQuickProjectSourceId}, storage.synchronize(SynchronizationPackage{{qmlProjectSourceId, qtQuickProjectSourceId},
{projectData1, projectData2, projectData3}}); {directoryInfo1, directoryInfo2, directoryInfo3}});
storage.synchronize(SynchronizationPackage{{qmlProjectSourceId}, {projectData1, projectData2b}}); storage.synchronize(SynchronizationPackage{{qmlProjectSourceId}, {directoryInfo1, directoryInfo2b}});
ASSERT_THAT(storage.fetchProjectDatas({qmlProjectSourceId, qtQuickProjectSourceId}), ASSERT_THAT(storage.fetchDirectoryInfos({qmlProjectSourceId, qtQuickProjectSourceId}),
UnorderedElementsAre(projectData1, projectData2b, projectData3)); UnorderedElementsAre(directoryInfo1, directoryInfo2b, directoryInfo3));
} }
TEST_F(ProjectStorage, throw_for_invalid_source_id_in_project_data) TEST_F(ProjectStorage, throw_for_invalid_source_id_in_directory_info)
{ {
Storage::Synchronization::ProjectData projectData1{qmlProjectSourceId, Storage::Synchronization::DirectoryInfo directoryInfo1{qmlProjectSourceId,
SourceId{}, SourceId{},
qmlModuleId, qmlModuleId,
Storage::Synchronization::FileType::QmlDocument}; Storage::Synchronization::FileType::QmlDocument};
ASSERT_THROW(storage.synchronize(SynchronizationPackage{{qmlProjectSourceId}, {projectData1}}), ASSERT_THROW(storage.synchronize(SynchronizationPackage{{qmlProjectSourceId}, {directoryInfo1}}),
QmlDesigner::ProjectDataHasInvalidSourceId); QmlDesigner::DirectoryInfoHasInvalidSourceId);
} }
TEST_F(ProjectStorage, insert_project_data_with_invalid_module_id) TEST_F(ProjectStorage, insert_directory_info_with_invalid_module_id)
{ {
Storage::Synchronization::ProjectData projectData1{qmlProjectSourceId, Storage::Synchronization::DirectoryInfo directoryInfo1{qmlProjectSourceId,
sourceId1, sourceId1,
ModuleId{}, ModuleId{},
Storage::Synchronization::FileType::QmlDocument}; Storage::Synchronization::FileType::QmlDocument};
storage.synchronize(SynchronizationPackage{{qmlProjectSourceId}, {projectData1}}); storage.synchronize(SynchronizationPackage{{qmlProjectSourceId}, {directoryInfo1}});
ASSERT_THAT(storage.fetchProjectDatas({qmlProjectSourceId, qtQuickProjectSourceId}), ASSERT_THAT(storage.fetchDirectoryInfos({qmlProjectSourceId, qtQuickProjectSourceId}),
UnorderedElementsAre(projectData1)); UnorderedElementsAre(directoryInfo1));
} }
TEST_F(ProjectStorage, update_project_data_with_invalid_module_id) TEST_F(ProjectStorage, update_directory_info_with_invalid_module_id)
{ {
Storage::Synchronization::ProjectData projectData1{qmlProjectSourceId, Storage::Synchronization::DirectoryInfo directoryInfo1{qmlProjectSourceId,
sourceId1, sourceId1,
qmlModuleId, qmlModuleId,
Storage::Synchronization::FileType::QmlDocument}; Storage::Synchronization::FileType::QmlDocument};
storage.synchronize(SynchronizationPackage{{qmlProjectSourceId}, {projectData1}}); storage.synchronize(SynchronizationPackage{{qmlProjectSourceId}, {directoryInfo1}});
projectData1.moduleId = ModuleId{}; directoryInfo1.moduleId = ModuleId{};
storage.synchronize(SynchronizationPackage{{qmlProjectSourceId}, {projectData1}}); storage.synchronize(SynchronizationPackage{{qmlProjectSourceId}, {directoryInfo1}});
ASSERT_THAT(storage.fetchProjectDatas({qmlProjectSourceId, qtQuickProjectSourceId}), ASSERT_THAT(storage.fetchDirectoryInfos({qmlProjectSourceId, qtQuickProjectSourceId}),
UnorderedElementsAre(projectData1)); UnorderedElementsAre(directoryInfo1));
} }
TEST_F(ProjectStorage, throw_for_updating_with_invalid_project_source_id_in_project_data) TEST_F(ProjectStorage, throw_for_updating_with_invalid_project_source_id_in_directory_info)
{ {
Storage::Synchronization::ProjectData projectData1{SourceId{}, Storage::Synchronization::DirectoryInfo directoryInfo1{SourceId{},
sourceId1, sourceId1,
qmlModuleId, qmlModuleId,
Storage::Synchronization::FileType::QmlDocument}; Storage::Synchronization::FileType::QmlDocument};
ASSERT_THROW(storage.synchronize(SynchronizationPackage{{qmlProjectSourceId}, {projectData1}}), ASSERT_THROW(storage.synchronize(SynchronizationPackage{{qmlProjectSourceId}, {directoryInfo1}}),
QmlDesigner::ProjectDataHasInvalidProjectSourceId); QmlDesigner::DirectoryInfoHasInvalidProjectSourceId);
} }
TEST_F(ProjectStorage, fetch_project_datas_by_directory_source_ids) TEST_F(ProjectStorage, fetch_directory_infos_by_directory_source_ids)
{ {
Storage::Synchronization::ProjectData projectData1{qmlProjectSourceId, Storage::Synchronization::DirectoryInfo directoryInfo1{qmlProjectSourceId,
sourceId1, sourceId1,
qmlModuleId, qmlModuleId,
Storage::Synchronization::FileType::QmlDocument}; Storage::Synchronization::FileType::QmlDocument};
Storage::Synchronization::ProjectData projectData2{qmlProjectSourceId, Storage::Synchronization::DirectoryInfo directoryInfo2{qmlProjectSourceId,
sourceId2, sourceId2,
qmlModuleId, qmlModuleId,
Storage::Synchronization::FileType::QmlDocument}; Storage::Synchronization::FileType::QmlDocument};
Storage::Synchronization::ProjectData projectData3{qtQuickProjectSourceId, Storage::Synchronization::DirectoryInfo directoryInfo3{qtQuickProjectSourceId,
sourceId3, sourceId3,
qtQuickModuleId, qtQuickModuleId,
Storage::Synchronization::FileType::QmlTypes}; Storage::Synchronization::FileType::QmlTypes};
storage.synchronize(SynchronizationPackage{{qmlProjectSourceId, qtQuickProjectSourceId}, storage.synchronize(SynchronizationPackage{{qmlProjectSourceId, qtQuickProjectSourceId},
{projectData1, projectData2, projectData3}}); {directoryInfo1, directoryInfo2, directoryInfo3}});
auto projectDatas = storage.fetchProjectDatas({qmlProjectSourceId, qtQuickProjectSourceId}); auto directoryInfos = storage.fetchDirectoryInfos({qmlProjectSourceId, qtQuickProjectSourceId});
ASSERT_THAT(projectDatas, UnorderedElementsAre(projectData1, projectData2, projectData3)); ASSERT_THAT(directoryInfos, UnorderedElementsAre(directoryInfo1, directoryInfo2, directoryInfo3));
} }
TEST_F(ProjectStorage, fetch_project_datas_by_directory_source_id) TEST_F(ProjectStorage, fetch_directory_infos_by_directory_source_id)
{ {
Storage::Synchronization::ProjectData projectData1{qmlProjectSourceId, Storage::Synchronization::DirectoryInfo directoryInfo1{qmlProjectSourceId,
sourceId1, sourceId1,
qmlModuleId, qmlModuleId,
Storage::Synchronization::FileType::QmlDocument}; Storage::Synchronization::FileType::QmlDocument};
Storage::Synchronization::ProjectData projectData2{qmlProjectSourceId, Storage::Synchronization::DirectoryInfo directoryInfo2{qmlProjectSourceId,
sourceId2, sourceId2,
qmlModuleId, qmlModuleId,
Storage::Synchronization::FileType::QmlDocument}; Storage::Synchronization::FileType::QmlDocument};
Storage::Synchronization::ProjectData projectData3{qtQuickProjectSourceId, Storage::Synchronization::DirectoryInfo directoryInfo3{qtQuickProjectSourceId,
sourceId3, sourceId3,
qtQuickModuleId, qtQuickModuleId,
Storage::Synchronization::FileType::QmlTypes}; Storage::Synchronization::FileType::QmlTypes};
storage.synchronize(SynchronizationPackage{{qmlProjectSourceId, qtQuickProjectSourceId}, storage.synchronize(SynchronizationPackage{{qmlProjectSourceId, qtQuickProjectSourceId},
{projectData1, projectData2, projectData3}}); {directoryInfo1, directoryInfo2, directoryInfo3}});
auto projectData = storage.fetchProjectDatas(qmlProjectSourceId); auto directoryInfo = storage.fetchDirectoryInfos(qmlProjectSourceId);
ASSERT_THAT(projectData, UnorderedElementsAre(projectData1, projectData2)); ASSERT_THAT(directoryInfo, UnorderedElementsAre(directoryInfo1, directoryInfo2));
} }
TEST_F(ProjectStorage, fetch_project_data_by_source_ids) TEST_F(ProjectStorage, fetch_directory_info_by_source_ids)
{ {
Storage::Synchronization::ProjectData projectData1{qmlProjectSourceId, Storage::Synchronization::DirectoryInfo directoryInfo1{qmlProjectSourceId,
sourceId1, sourceId1,
qmlModuleId, qmlModuleId,
Storage::Synchronization::FileType::QmlDocument}; Storage::Synchronization::FileType::QmlDocument};
Storage::Synchronization::ProjectData projectData2{qmlProjectSourceId, Storage::Synchronization::DirectoryInfo directoryInfo2{qmlProjectSourceId,
sourceId2, sourceId2,
qmlModuleId, qmlModuleId,
Storage::Synchronization::FileType::QmlDocument}; Storage::Synchronization::FileType::QmlDocument};
Storage::Synchronization::ProjectData projectData3{qtQuickProjectSourceId, Storage::Synchronization::DirectoryInfo directoryInfo3{qtQuickProjectSourceId,
sourceId3, sourceId3,
qtQuickModuleId, qtQuickModuleId,
Storage::Synchronization::FileType::QmlTypes}; Storage::Synchronization::FileType::QmlTypes};
storage.synchronize(SynchronizationPackage{{qmlProjectSourceId, qtQuickProjectSourceId}, storage.synchronize(SynchronizationPackage{{qmlProjectSourceId, qtQuickProjectSourceId},
{projectData1, projectData2, projectData3}}); {directoryInfo1, directoryInfo2, directoryInfo3}});
auto projectData = storage.fetchProjectData({sourceId2}); auto directoryInfo = storage.fetchDirectoryInfo({sourceId2});
ASSERT_THAT(projectData, Eq(projectData2)); ASSERT_THAT(directoryInfo, Eq(directoryInfo2));
} }
TEST_F(ProjectStorage, exclude_exported_types) TEST_F(ProjectStorage, exclude_exported_types)

813
tests/unit/tests/unittests/projectstorage/projectstorageupdater-test.cpp
View File

File diff suppressed because it is too large Load Diff

58
tests/unit/tests/unittests/projectstorage/qmltypesparser-test.cpp
View File

@@ -177,7 +177,7 @@ protected:
Synchronization::Types types; Synchronization::Types types;
SourceId qmltypesFileSourceId{sourcePathCache.sourceId("path/to/types.qmltypes")}; SourceId qmltypesFileSourceId{sourcePathCache.sourceId("path/to/types.qmltypes")};
ModuleId qtQmlNativeModuleId = storage.moduleId("QtQml", ModuleKind::CppLibrary); ModuleId qtQmlNativeModuleId = storage.moduleId("QtQml", ModuleKind::CppLibrary);
Synchronization::ProjectData projectData{qmltypesFileSourceId, Synchronization::DirectoryInfo directoryInfo{qmltypesFileSourceId,
qmltypesFileSourceId, qmltypesFileSourceId,
qtQmlNativeModuleId, qtQmlNativeModuleId,
Synchronization::FileType::QmlTypes}; Synchronization::FileType::QmlTypes};
@@ -191,7 +191,7 @@ TEST_F(QmlTypesParser, imports)
dependencies: dependencies:
["QtQuick 2.15", "QtQuick.Window 2.1", "QtFoo 6"]})"}; ["QtQuick 2.15", "QtQuick.Window 2.1", "QtFoo 6"]})"};
parser.parse(source, imports, types, projectData); parser.parse(source, imports, types, directoryInfo);
ASSERT_THAT(imports, ASSERT_THAT(imports,
UnorderedElementsAre(IsImport(storage.moduleId("QML", ModuleKind::CppLibrary), UnorderedElementsAre(IsImport(storage.moduleId("QML", ModuleKind::CppLibrary),
@@ -218,7 +218,7 @@ TEST_F(QmlTypesParser, types)
Component { name: "QObject"} Component { name: "QObject"}
Component { name: "QQmlComponent"}})"}; Component { name: "QQmlComponent"}})"};
parser.parse(source, imports, types, projectData); parser.parse(source, imports, types, directoryInfo);
ASSERT_THAT(types, ASSERT_THAT(types,
UnorderedElementsAre(IsType("QObject", UnorderedElementsAre(IsType("QObject",
@@ -241,7 +241,7 @@ TEST_F(QmlTypesParser, prototype)
Component { name: "QQmlComponent" Component { name: "QQmlComponent"
prototype: "QObject"}})"}; prototype: "QObject"}})"};
parser.parse(source, imports, types, projectData); parser.parse(source, imports, types, directoryInfo);
ASSERT_THAT(types, ASSERT_THAT(types,
UnorderedElementsAre(IsType("QObject", UnorderedElementsAre(IsType("QObject",
@@ -264,7 +264,7 @@ TEST_F(QmlTypesParser, extension)
Component { name: "QQmlComponent" Component { name: "QQmlComponent"
extension: "QObject"}})"}; extension: "QObject"}})"};
parser.parse(source, imports, types, projectData); parser.parse(source, imports, types, directoryInfo);
ASSERT_THAT(types, ASSERT_THAT(types,
UnorderedElementsAre(IsType("QObject", UnorderedElementsAre(IsType("QObject",
@@ -289,7 +289,7 @@ TEST_F(QmlTypesParser, exported_types)
ModuleId qmlModuleId = storage.moduleId("QML", ModuleKind::QmlLibrary); ModuleId qmlModuleId = storage.moduleId("QML", ModuleKind::QmlLibrary);
ModuleId qtQmlModuleId = storage.moduleId("QtQml", ModuleKind::QmlLibrary); ModuleId qtQmlModuleId = storage.moduleId("QtQml", ModuleKind::QmlLibrary);
parser.parse(source, imports, types, projectData); parser.parse(source, imports, types, directoryInfo);
ASSERT_THAT( ASSERT_THAT(
types, types,
@@ -312,7 +312,7 @@ TEST_F(QmlTypesParser, properties)
Property { name: "targets"; type: "QQuickItem"; isList: true; isReadonly: true; isPointer: true } Property { name: "targets"; type: "QQuickItem"; isList: true; isReadonly: true; isPointer: true }
}})"}; }})"};
parser.parse(source, imports, types, projectData); parser.parse(source, imports, types, directoryInfo);
ASSERT_THAT(types, ASSERT_THAT(types,
ElementsAre(Field( ElementsAre(Field(
@@ -346,7 +346,7 @@ TEST_F(QmlTypesParser, properties_with_qualified_types)
Property { name: "values2"; type: "Qt::Vector" } Property { name: "values2"; type: "Qt::Vector" }
}})"}; }})"};
parser.parse(source, imports, types, projectData); parser.parse(source, imports, types, directoryInfo);
ASSERT_THAT(types, ASSERT_THAT(types,
Contains( Contains(
@@ -372,7 +372,7 @@ TEST_F(QmlTypesParser, properties_without_type)
Property { name: "target"; type: "QObject"; isPointer: true } Property { name: "target"; type: "QObject"; isPointer: true }
}})"}; }})"};
parser.parse(source, imports, types, projectData); parser.parse(source, imports, types, directoryInfo);
ASSERT_THAT(types, ASSERT_THAT(types,
ElementsAre( ElementsAre(
@@ -405,7 +405,7 @@ TEST_F(QmlTypesParser, functions)
} }
}})"}; }})"};
parser.parse(source, imports, types, projectData); parser.parse(source, imports, types, directoryInfo);
ASSERT_THAT(types, ASSERT_THAT(types,
ElementsAre(Field( ElementsAre(Field(
@@ -436,7 +436,7 @@ TEST_F(QmlTypesParser, skip_java_script_functions)
} }
}})"}; }})"};
parser.parse(source, imports, types, projectData); parser.parse(source, imports, types, directoryInfo);
ASSERT_THAT(types, ElementsAre(Field(&Synchronization::Type::functionDeclarations, IsEmpty()))); ASSERT_THAT(types, ElementsAre(Field(&Synchronization::Type::functionDeclarations, IsEmpty())));
} }
@@ -456,7 +456,7 @@ TEST_F(QmlTypesParser, functions_with_qualified_types)
} }
}})"}; }})"};
parser.parse(source, imports, types, projectData); parser.parse(source, imports, types, directoryInfo);
ASSERT_THAT(types, ASSERT_THAT(types,
Contains( Contains(
@@ -491,7 +491,7 @@ TEST_F(QmlTypesParser, signals)
} }
}})"}; }})"};
parser.parse(source, imports, types, projectData); parser.parse(source, imports, types, directoryInfo);
ASSERT_THAT(types, ASSERT_THAT(types,
ElementsAre(Field(&Synchronization::Type::signalDeclarations, ElementsAre(Field(&Synchronization::Type::signalDeclarations,
@@ -524,7 +524,7 @@ TEST_F(QmlTypesParser, signals_with_qualified_types)
} }
}})"}; }})"};
parser.parse(source, imports, types, projectData); parser.parse(source, imports, types, directoryInfo);
ASSERT_THAT(types, ASSERT_THAT(types,
Contains( Contains(
@@ -557,7 +557,7 @@ TEST_F(QmlTypesParser, enumerations)
} }
}})"}; }})"};
parser.parse(source, imports, types, projectData); parser.parse(source, imports, types, directoryInfo);
ASSERT_THAT(types, ASSERT_THAT(types,
Contains(Field( Contains(Field(
@@ -596,7 +596,7 @@ TEST_F(QmlTypesParser, enumeration_is_exported_as_type)
exports: ["QML/QtObject 1.0", "QtQml/QtObject 2.1"] exports: ["QML/QtObject 1.0", "QtQml/QtObject 2.1"]
}})"}; }})"};
parser.parse(source, imports, types, projectData); parser.parse(source, imports, types, directoryInfo);
QmlDesigner::Storage::TypeTraits traits{QmlDesigner::Storage::TypeTraitsKind::Value}; QmlDesigner::Storage::TypeTraits traits{QmlDesigner::Storage::TypeTraitsKind::Value};
traits.isEnum = true; traits.isEnum = true;
@@ -642,7 +642,7 @@ TEST_F(QmlTypesParser, enumeration_is_exported_as_type_with_alias)
exports: ["QML/QtObject 1.0", "QtQml/QtObject 2.1"] exports: ["QML/QtObject 1.0", "QtQml/QtObject 2.1"]
}})"}; }})"};
parser.parse(source, imports, types, projectData); parser.parse(source, imports, types, directoryInfo);
QmlDesigner::Storage::TypeTraits traits{QmlDesigner::Storage::TypeTraitsKind::Value}; QmlDesigner::Storage::TypeTraits traits{QmlDesigner::Storage::TypeTraitsKind::Value};
traits.isEnum = true; traits.isEnum = true;
@@ -690,7 +690,7 @@ TEST_F(QmlTypesParser, enumeration_is_exported_as_type_with_alias_too)
exports: ["QML/QtObject 1.0", "QtQml/QtObject 2.1"] exports: ["QML/QtObject 1.0", "QtQml/QtObject 2.1"]
}})"}; }})"};
parser.parse(source, imports, types, projectData); parser.parse(source, imports, types, directoryInfo);
QmlDesigner::Storage::TypeTraits traits{QmlDesigner::Storage::TypeTraitsKind::Value}; QmlDesigner::Storage::TypeTraits traits{QmlDesigner::Storage::TypeTraitsKind::Value};
traits.isEnum = true; traits.isEnum = true;
@@ -728,7 +728,7 @@ TEST_F(QmlTypesParser, enumeration_is_referenced_by_qualified_name)
} }
}})"}; }})"};
parser.parse(source, imports, types, projectData); parser.parse(source, imports, types, directoryInfo);
ASSERT_THAT(types, ASSERT_THAT(types,
Contains(Field(&Synchronization::Type::propertyDeclarations, Contains(Field(&Synchronization::Type::propertyDeclarations,
@@ -756,7 +756,7 @@ TEST_F(QmlTypesParser, alias_enumeration_is_referenced_by_qualified_name)
} }
}})"}; }})"};
parser.parse(source, imports, types, projectData); parser.parse(source, imports, types, directoryInfo);
ASSERT_THAT(types, ASSERT_THAT(types,
Contains(Field(&Synchronization::Type::propertyDeclarations, Contains(Field(&Synchronization::Type::propertyDeclarations,
@@ -773,7 +773,7 @@ TEST_F(QmlTypesParser, access_type_is_reference)
Component { name: "QObject" Component { name: "QObject"
accessSemantics: "reference"}})"}; accessSemantics: "reference"}})"};
parser.parse(source, imports, types, projectData); parser.parse(source, imports, types, directoryInfo);
ASSERT_THAT(types, ElementsAre(IsTypeTrait(Storage::TypeTraitsKind::Reference))); ASSERT_THAT(types, ElementsAre(IsTypeTrait(Storage::TypeTraitsKind::Reference)));
} }
@@ -785,7 +785,7 @@ TEST_F(QmlTypesParser, access_type_is_value)
Component { name: "QObject" Component { name: "QObject"
accessSemantics: "value"}})"}; accessSemantics: "value"}})"};
parser.parse(source, imports, types, projectData); parser.parse(source, imports, types, directoryInfo);
ASSERT_THAT(types, ElementsAre(IsTypeTrait(Storage::TypeTraitsKind::Value))); ASSERT_THAT(types, ElementsAre(IsTypeTrait(Storage::TypeTraitsKind::Value)));
} }
@@ -797,7 +797,7 @@ TEST_F(QmlTypesParser, access_type_is_sequence)
Component { name: "QObject" Component { name: "QObject"
accessSemantics: "sequence"}})"}; accessSemantics: "sequence"}})"};
parser.parse(source, imports, types, projectData); parser.parse(source, imports, types, directoryInfo);
ASSERT_THAT(types, ElementsAre(IsTypeTrait(Storage::TypeTraitsKind::Sequence))); ASSERT_THAT(types, ElementsAre(IsTypeTrait(Storage::TypeTraitsKind::Sequence)));
} }
@@ -809,7 +809,7 @@ TEST_F(QmlTypesParser, access_type_is_none)
Component { name: "QObject" Component { name: "QObject"
accessSemantics: "none"}})"}; accessSemantics: "none"}})"};
parser.parse(source, imports, types, projectData); parser.parse(source, imports, types, directoryInfo);
ASSERT_THAT(types, ElementsAre(IsTypeTrait(Storage::TypeTraitsKind::None))); ASSERT_THAT(types, ElementsAre(IsTypeTrait(Storage::TypeTraitsKind::None)));
} }
@@ -821,7 +821,7 @@ TEST_F(QmlTypesParser, uses_custom_parser)
Component { name: "QObject" Component { name: "QObject"
hasCustomParser: true }})"}; hasCustomParser: true }})"};
parser.parse(source, imports, types, projectData); parser.parse(source, imports, types, directoryInfo);
ASSERT_THAT(types, ElementsAre(IsTypeTrait(UsesCustomParser(true)))); ASSERT_THAT(types, ElementsAre(IsTypeTrait(UsesCustomParser(true))));
} }
@@ -833,7 +833,7 @@ TEST_F(QmlTypesParser, uses_no_custom_parser)
Component { name: "QObject" Component { name: "QObject"
hasCustomParser: false }})"}; hasCustomParser: false }})"};
parser.parse(source, imports, types, projectData); parser.parse(source, imports, types, directoryInfo);
ASSERT_THAT(types, ElementsAre(IsTypeTrait(UsesCustomParser(false)))); ASSERT_THAT(types, ElementsAre(IsTypeTrait(UsesCustomParser(false))));
} }
@@ -845,7 +845,7 @@ TEST_F(QmlTypesParser, default_property)
Component { name: "QObject" Component { name: "QObject"
defaultProperty: "children" }})"}; defaultProperty: "children" }})"};
parser.parse(source, imports, types, projectData); parser.parse(source, imports, types, directoryInfo);
ASSERT_THAT(types, ASSERT_THAT(types,
ElementsAre(Field(&Synchronization::Type::defaultPropertyName, Eq("children")))); ElementsAre(Field(&Synchronization::Type::defaultPropertyName, Eq("children"))));
@@ -854,7 +854,7 @@ TEST_F(QmlTypesParser, default_property)
TEST_F(QmlTypesParser, skip_template_item) TEST_F(QmlTypesParser, skip_template_item)
{ {
ModuleId moduleId = storage.moduleId("QtQuick.Templates", ModuleKind::CppLibrary); ModuleId moduleId = storage.moduleId("QtQuick.Templates", ModuleKind::CppLibrary);
Synchronization::ProjectData projectData{qmltypesFileSourceId, Synchronization::DirectoryInfo directoryInfo{qmltypesFileSourceId,
qmltypesFileSourceId, qmltypesFileSourceId,
moduleId, moduleId,
Synchronization::FileType::QmlTypes}; Synchronization::FileType::QmlTypes};
@@ -863,7 +863,7 @@ TEST_F(QmlTypesParser, skip_template_item)
Component { name: "QQuickItem"} Component { name: "QQuickItem"}
Component { name: "QQmlComponent"}})"}; Component { name: "QQmlComponent"}})"};
parser.parse(source, imports, types, projectData); parser.parse(source, imports, types, directoryInfo);
ASSERT_THAT(types, ASSERT_THAT(types,
UnorderedElementsAre(IsType("QQmlComponent", UnorderedElementsAre(IsType("QQmlComponent",