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

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

@@ -229,11 +229,11 @@ public:
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);
@@ -560,7 +560,7 @@ private:
Prototypes &relinkableExtensions,
const SourceIds &updatedSourceIds);
void synchronizeProjectDatas(Storage::Synchronization::ProjectDatas &projectDatas,
void synchronizeDirectoryInfos(Storage::Synchronization::DirectoryInfos &directoryInfos,
const SourceIds &updatedProjectSourceIds);
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!";
}
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!";
}
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!";
}
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!";
}

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

@@ -130,24 +130,24 @@ public:
const char *what() const noexcept override;
};
class QMLDESIGNERCORE_EXPORT ProjectDataHasInvalidProjectSourceId : public ProjectStorageError
class QMLDESIGNERCORE_EXPORT DirectoryInfoHasInvalidProjectSourceId : public ProjectStorageError
{
public:
ProjectDataHasInvalidProjectSourceId();
DirectoryInfoHasInvalidProjectSourceId();
const char *what() const noexcept override;
};
class QMLDESIGNERCORE_EXPORT ProjectDataHasInvalidSourceId : public ProjectStorageError
class QMLDESIGNERCORE_EXPORT DirectoryInfoHasInvalidSourceId : public ProjectStorageError
{
public:
ProjectDataHasInvalidSourceId();
DirectoryInfoHasInvalidSourceId();
const char *what() const noexcept override;
};
class QMLDESIGNERCORE_EXPORT ProjectDataHasInvalidModuleId : public ProjectStorageError
class QMLDESIGNERCORE_EXPORT DirectoryInfoHasInvalidModuleId : public ProjectStorageError
{
public:
ProjectDataHasInvalidModuleId();
DirectoryInfoHasInvalidModuleId();
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 FileStatus fetchFileStatus(SourceId sourceId) const = 0;
virtual Storage::Synchronization::ProjectDatas fetchProjectDatas(SourceId sourceId) const = 0;
virtual std::optional<Storage::Synchronization::ProjectData> fetchProjectData(SourceId sourceId) const = 0;
virtual Storage::Synchronization::DirectoryInfos fetchDirectoryInfos(SourceId sourceId) const = 0;
virtual std::optional<Storage::Synchronization::DirectoryInfo> fetchDirectoryInfo(SourceId sourceId) const = 0;
virtual SourceId propertyEditorPathId(TypeId typeId) 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>;
class ProjectData
class DirectoryInfo
{
public:
ProjectData(SourceId projectSourceId, SourceId sourceId, ModuleId moduleId, FileType fileType)
: projectSourceId{projectSourceId}
DirectoryInfo(SourceId directorySourceId, SourceId sourceId, ModuleId moduleId, FileType fileType)
: directorySourceId{directorySourceId}
, sourceId{sourceId}
, moduleId{moduleId}
, 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.fileType == second.fileType;
}
template<typename String>
friend void convertToString(String &string, const ProjectData &projectData)
friend void convertToString(String &string, const DirectoryInfo &directoryInfo)
{
using NanotraceHR::dictonary;
using NanotraceHR::keyValue;
auto dict = dictonary(keyValue("project source id", projectData.projectSourceId),
keyValue("source id", projectData.sourceId),
keyValue("module id", projectData.moduleId),
keyValue("file type", projectData.fileType));
auto dict = dictonary(keyValue("project source id", directoryInfo.directorySourceId),
keyValue("source id", directoryInfo.sourceId),
keyValue("module id", directoryInfo.moduleId),
keyValue("file type", directoryInfo.fileType));
convertToString(string, dict);
}
public:
SourceId projectSourceId;
SourceId directorySourceId;
SourceId sourceId;
ModuleId moduleId;
FileType fileType;
};
using ProjectDatas = std::vector<ProjectData>;
using DirectoryInfos = std::vector<DirectoryInfo>;
class TypeAnnotation
{
@@ -1291,8 +1291,8 @@ public:
, fileStatuses(std::move(fileStatuses))
{}
SynchronizationPackage(SourceIds updatedProjectSourceIds, ProjectDatas projectDatas)
: projectDatas(std::move(projectDatas))
SynchronizationPackage(SourceIds updatedProjectSourceIds, DirectoryInfos directoryInfos)
: directoryInfos(std::move(directoryInfos))
, updatedProjectSourceIds(std::move(updatedProjectSourceIds))
{}
@@ -1302,7 +1302,7 @@ public:
SourceIds updatedSourceIds;
SourceIds updatedFileStatusSourceIds;
FileStatuses fileStatuses;
ProjectDatas projectDatas;
DirectoryInfos directoryInfos;
SourceIds updatedProjectSourceIds;
Imports moduleDependencies;
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,
const Storage::Synchronization::ProjectDatas &projectDatas,
const Storage::Synchronization::DirectoryInfos &directoryInfos,
TracerLiteral message,
Tracer &tracer)
{
for (const auto &projectData : projectDatas) {
tracer.tick(message, keyValue("source id", projectData.sourceId));
sourceIds.push_back(projectData.sourceId);
for (const auto &directoryInfo : directoryInfos) {
tracer.tick(message, keyValue("source id", directoryInfo.sourceId));
sourceIds.push_back(directoryInfo.sourceId);
}
}
@@ -311,19 +311,17 @@ void ProjectStorageUpdater::updateQmlTypes(const QStringList &qmlTypesPaths,
keyValue("source id", sourceId),
keyValue("qml types path", qmlTypesPath));
Storage::Synchronization::ProjectData projectData{sourceId,
sourceId,
moduleId,
Storage::Synchronization::FileType::QmlTypes};
Storage::Synchronization::DirectoryInfo directoryInfo{
sourceId, sourceId, moduleId, Storage::Synchronization::FileType::QmlTypes};
FileState state = parseTypeInfo(projectData,
FileState state = parseTypeInfo(directoryInfo,
Utils::PathString{qmlTypesPath},
package,
notUpdatedSourceIds);
if (state == FileState::Changed) {
tracer.tick("append project data"_t, keyValue("project data", projectData));
package.projectDatas.push_back(std::move(projectData));
tracer.tick("append project data"_t, keyValue("project data", directoryInfo));
package.directoryInfos.push_back(std::move(directoryInfo));
tracer.tick("append updated project source ids"_t, keyValue("source id", 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));
package.updatedModuleIds.push_back(moduleId);
const auto qmlProjectDatas = m_projectStorage.fetchProjectDatas(directorySourceId);
addSourceIds(package.updatedSourceIds, qmlProjectDatas, "append updated source id"_t, tracer);
const auto qmlDirectoryInfos = m_projectStorage.fetchDirectoryInfos(directorySourceId);
addSourceIds(package.updatedSourceIds, qmlDirectoryInfos, "append updated source id"_t, tracer);
addSourceIds(package.updatedFileStatusSourceIds,
qmlProjectDatas,
qmlDirectoryInfos,
"append updated file status source id"_t,
tracer);
@@ -463,10 +461,10 @@ void ProjectStorageUpdater::updateDirectory(const Utils::PathString &directoryPa
case FileState::NotChanged: {
tracer.tick("update directory not changed"_t);
parseProjectDatas(m_projectStorage.fetchProjectDatas(directorySourceId),
package,
notUpdatedSourceIds,
watchedSourceIdsIds);
parseDirectoryInfos(m_projectStorage.fetchDirectoryInfos(directorySourceId),
package,
notUpdatedSourceIds,
watchedSourceIdsIds);
break;
}
case FileState::NotExists: {
@@ -476,13 +474,13 @@ void ProjectStorageUpdater::updateDirectory(const Utils::PathString &directoryPa
package.updatedFileStatusSourceIds.push_back(qmldirSourceId);
package.updatedProjectSourceIds.push_back(directorySourceId);
package.updatedSourceIds.push_back(qmldirSourceId);
auto qmlProjectDatas = m_projectStorage.fetchProjectDatas(directorySourceId);
for (const Storage::Synchronization::ProjectData &projectData : qmlProjectDatas) {
tracer.tick("append updated source id"_t, keyValue("source id", projectData.sourceId));
package.updatedSourceIds.push_back(projectData.sourceId);
auto qmlDirectoryInfos = m_projectStorage.fetchDirectoryInfos(directorySourceId);
for (const Storage::Synchronization::DirectoryInfo &directoryInfo : qmlDirectoryInfos) {
tracer.tick("append updated source id"_t, keyValue("source id", directoryInfo.sourceId));
package.updatedSourceIds.push_back(directoryInfo.sourceId);
tracer.tick("append updated file status source id"_t,
keyValue("source id", projectData.sourceId));
package.updatedFileStatusSourceIds.push_back(projectData.sourceId);
keyValue("source id", directoryInfo.sourceId));
package.updatedFileStatusSourceIds.push_back(directoryInfo.sourceId);
}
break;
@@ -802,9 +800,9 @@ void ProjectStorageUpdater::pathsWithIdsChanged(const std::vector<IdPaths> &chan
for (SourceId sourceId : filterUniqueSourceIds(std::move(qmltypesSourceIds))) {
if (!contains(directorySourceContextIds, m_pathCache.sourceContextId(sourceId))) {
auto qmltypesPath = m_pathCache.sourcePath(sourceId);
auto projectData = m_projectStorage.fetchProjectData(sourceId);
if (projectData)
parseTypeInfo(*projectData, qmltypesPath, package, notUpdatedSourceIds);
auto directoryInfo = m_projectStorage.fetchDirectoryInfo(sourceId);
if (directoryInfo)
parseTypeInfo(*directoryInfo, qmltypesPath, package, notUpdatedSourceIds);
}
}
} 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));
package.updatedModuleDependencySourceIds.push_back(sourceId);
auto projectData = package.projectDatas.emplace_back(
auto directoryInfo = package.directoryInfos.emplace_back(
directorySourceId, sourceId, moduleId, Storage::Synchronization::FileType::QmlTypes);
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,
Storage::Synchronization::SynchronizationPackage &package,
NotUpdatedSourceIds &notUpdatedSourceIds,
WatchedSourceIdsIds &watchedSourceIds)
void ProjectStorageUpdater::parseDirectoryInfos(
const Storage::Synchronization::DirectoryInfos &directoryInfos,
Storage::Synchronization::SynchronizationPackage &package,
NotUpdatedSourceIds &notUpdatedSourceIds,
WatchedSourceIdsIds &watchedSourceIds)
{
NanotraceHR::Tracer tracer{"parse project datas"_t, category()};
for (const Storage::Synchronization::ProjectData &projectData : projectDatas) {
switch (projectData.fileType) {
for (const Storage::Synchronization::DirectoryInfo &directoryInfo : directoryInfos) {
switch (directoryInfo.fileType) {
case Storage::Synchronization::FileType::QmlTypes: {
watchedSourceIds.qmltypesSourceIds.push_back(projectData.sourceId);
watchedSourceIds.qmltypesSourceIds.push_back(directoryInfo.sourceId);
auto qmltypesPath = m_pathCache.sourcePath(projectData.sourceId);
parseTypeInfo(projectData, qmltypesPath, package, notUpdatedSourceIds);
auto qmltypesPath = m_pathCache.sourcePath(directoryInfo.sourceId);
parseTypeInfo(directoryInfo, qmltypesPath, package, notUpdatedSourceIds);
break;
}
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;
}
}
}
}
auto ProjectStorageUpdater::parseTypeInfo(const Storage::Synchronization::ProjectData &projectData,
auto ProjectStorageUpdater::parseTypeInfo(const Storage::Synchronization::DirectoryInfo &directoryInfo,
Utils::SmallStringView qmltypesPath,
Storage::Synchronization::SynchronizationPackage &package,
NotUpdatedSourceIds &notUpdatedSourceIds) -> FileState
@@ -912,19 +911,19 @@ auto ProjectStorageUpdater::parseTypeInfo(const Storage::Synchronization::Projec
category(),
keyValue("qmltypes path", qmltypesPath)};
auto state = fileState(projectData.sourceId, package, notUpdatedSourceIds);
auto state = fileState(directoryInfo.sourceId, package, notUpdatedSourceIds);
switch (state) {
case FileState::Changed: {
tracer.tick("append updated source ids"_t, keyValue("source id", projectData.sourceId));
package.updatedSourceIds.push_back(projectData.sourceId);
tracer.tick("append updated source ids"_t, keyValue("source id", directoryInfo.sourceId));
package.updatedSourceIds.push_back(directoryInfo.sourceId);
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;
}
case FileState::NotChanged: {
tracer.tick("append not updated source ids"_t, keyValue("source id", projectData.sourceId));
notUpdatedSourceIds.sourceIds.push_back(projectData.sourceId);
tracer.tick("append not updated source ids"_t, keyValue("source id", directoryInfo.sourceId));
notUpdatedSourceIds.sourceIds.push_back(directoryInfo.sourceId);
break;
}
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));
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);
tracer.tick("append project data"_t, keyValue("project data", projectData));
tracer.tick("append project data"_t, keyValue("project data", directoryInfo));
return;
}
@@ -987,9 +986,9 @@ void ProjectStorageUpdater::parseQmlComponent(Utils::SmallStringView relativeFil
break;
}
const auto &projectData = package.projectDatas.emplace_back(
const auto &directoryInfo = package.directoryInfos.emplace_back(
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));
package.updatedSourceIds.push_back(sourceId);

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

@@ -192,11 +192,11 @@ private:
Storage::Synchronization::SynchronizationPackage &package,
NotUpdatedSourceIds &notUpdatedSourceIds,
WatchedSourceIdsIds &watchedSourceIdsIds);
void parseProjectDatas(const Storage::Synchronization::ProjectDatas &projectDatas,
Storage::Synchronization::SynchronizationPackage &package,
NotUpdatedSourceIds &notUpdatedSourceIds,
WatchedSourceIdsIds &watchedSourceIdsIds);
FileState parseTypeInfo(const Storage::Synchronization::ProjectData &projectData,
void parseDirectoryInfos(const Storage::Synchronization::DirectoryInfos &directoryInfos,
Storage::Synchronization::SynchronizationPackage &package,
NotUpdatedSourceIds &notUpdatedSourceIds,
WatchedSourceIdsIds &watchedSourceIdsIds);
FileState parseTypeInfo(const Storage::Synchronization::DirectoryInfo &directoryInfo,
Utils::SmallStringView qmltypesPath,
Storage::Synchronization::SynchronizationPackage &package,
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,
const Storage::Synchronization::ProjectData &projectData,
const Storage::Synchronization::DirectoryInfo &directoryInfo,
const QList<QQmlJSExportedScope> &objects,
QmlTypesParser::ProjectStorage &storage,
const ComponentWithoutNamespaces &componentNameWithoutNamespaces)
@@ -503,15 +503,15 @@ void addTypes(Storage::Synchronization::Types &types,
NanotraceHR::Tracer tracer{"add types"_t, category()};
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) {
if (skipType(object, skipList))
continue;
addType(types,
projectData.sourceId,
projectData.moduleId,
directoryInfo.sourceId,
directoryInfo.moduleId,
object,
storage,
componentNameWithoutNamespaces);
@@ -523,7 +523,7 @@ void addTypes(Storage::Synchronization::Types &types,
void QmlTypesParser::parse(const QString &sourceContent,
Storage::Imports &imports,
Storage::Synchronization::Types &types,
const Storage::Synchronization::ProjectData &projectData)
const Storage::Synchronization::DirectoryInfo &directoryInfo)
{
NanotraceHR::Tracer tracer{"qmltypes parser parse"_t, category()};
@@ -536,8 +536,8 @@ void QmlTypesParser::parse(const QString &sourceContent,
auto componentNameWithoutNamespaces = createComponentNameWithoutNamespaces(components);
addImports(imports, projectData.sourceId, dependencies, m_storage, projectData.moduleId);
addTypes(types, projectData, components, m_storage, componentNameWithoutNamespaces);
addImports(imports, directoryInfo.sourceId, dependencies, m_storage, directoryInfo.moduleId);
addTypes(types, directoryInfo, components, m_storage, componentNameWithoutNamespaces);
}
#else
@@ -545,7 +545,7 @@ void QmlTypesParser::parse(const QString &sourceContent,
void QmlTypesParser::parse([[maybe_unused]] const QString &sourceContent,
[[maybe_unused]] Storage::Imports &imports,
[[maybe_unused]] Storage::Synchronization::Types &types,
[[maybe_unused]] const Storage::Synchronization::ProjectData &projectData)
[[maybe_unused]] const Storage::Synchronization::DirectoryInfo &directoryInfo)
{}
#endif

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

@@ -31,7 +31,7 @@ public:
void parse(const QString &sourceContent,
Storage::Imports &imports,
Storage::Synchronization::Types &types,
const Storage::Synchronization::ProjectData &projectData) override;
const Storage::Synchronization::DirectoryInfo &directoryInfo) override;
private:
#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,
Storage::Imports &imports,
Storage::Synchronization::Types &types,
const Storage::Synchronization::ProjectData &projectData)
const Storage::Synchronization::DirectoryInfo &directoryInfo)
= 0;
protected:

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

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

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

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

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

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

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

@@ -15,6 +15,6 @@ public:
(const QString &sourceContent,
QmlDesigner::Storage::Imports &imports,
QmlDesigner::Storage::Synchronization::Types &types,
const QmlDesigner::Storage::Synchronization::ProjectData &projectData),
const QmlDesigner::Storage::Synchronization::DirectoryInfo &directoryInfo),
(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
<< ", updatedFileStatusSourceIds: " << package.updatedFileStatusSourceIds
<< ", updatedProjectSourceIds: " << package.updatedProjectSourceIds
<< ", projectDatas: " << package.projectDatas
<< ", directoryInfos: " << package.directoryInfos
<< ", propertyEditorQmlPaths: " << package.propertyEditorQmlPaths
<< ", 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 << ")";
}

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

@@ -207,7 +207,7 @@ class EnumeratorDeclaration;
enum class ImportKind : char;
enum class IsAutoVersion : char;
enum class IsQualified : int;
class ProjectData;
class DirectoryInfo;
class SynchronizationPackage;
enum class FileType : 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 ImportKind &importKind);
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, FileType fileType);
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));
}
TEST_F(ProjectStorage, add_project_dataes)
TEST_F(ProjectStorage, add_directory_infoes)
{
Storage::Synchronization::ProjectData projectData1{qmlProjectSourceId,
Storage::Synchronization::DirectoryInfo directoryInfo1{qmlProjectSourceId,
sourceId1,
qmlModuleId,
Storage::Synchronization::FileType::QmlDocument};
Storage::Synchronization::ProjectData projectData2{qmlProjectSourceId,
Storage::Synchronization::DirectoryInfo directoryInfo2{qmlProjectSourceId,
sourceId2,
qmlModuleId,
Storage::Synchronization::FileType::QmlDocument};
Storage::Synchronization::ProjectData projectData3{qtQuickProjectSourceId,
Storage::Synchronization::DirectoryInfo directoryInfo3{qtQuickProjectSourceId,
sourceId3,
qtQuickModuleId,
Storage::Synchronization::FileType::QmlTypes};
storage.synchronize(SynchronizationPackage{{qmlProjectSourceId, qtQuickProjectSourceId},
{projectData1, projectData2, projectData3}});
{directoryInfo1, directoryInfo2, directoryInfo3}});
ASSERT_THAT(storage.fetchProjectDatas({qmlProjectSourceId, qtQuickProjectSourceId}),
UnorderedElementsAre(projectData1, projectData2, projectData3));
ASSERT_THAT(storage.fetchDirectoryInfos({qmlProjectSourceId, qtQuickProjectSourceId}),
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,
qmlModuleId,
Storage::Synchronization::FileType::QmlDocument};
Storage::Synchronization::ProjectData projectData2{qmlProjectSourceId,
Storage::Synchronization::DirectoryInfo directoryInfo2{qmlProjectSourceId,
sourceId2,
qmlModuleId,
Storage::Synchronization::FileType::QmlDocument};
Storage::Synchronization::ProjectData projectData3{qtQuickProjectSourceId,
Storage::Synchronization::DirectoryInfo directoryInfo3{qtQuickProjectSourceId,
sourceId3,
qtQuickModuleId,
Storage::Synchronization::FileType::QmlTypes};
storage.synchronize(SynchronizationPackage{{qmlProjectSourceId, qtQuickProjectSourceId},
{projectData1, projectData2, projectData3}});
{directoryInfo1, directoryInfo2, directoryInfo3}});
storage.synchronize(
SynchronizationPackage{{qmlProjectSourceId, qtQuickProjectSourceId}, {projectData1}});
SynchronizationPackage{{qmlProjectSourceId, qtQuickProjectSourceId}, {directoryInfo1}});
ASSERT_THAT(storage.fetchProjectDatas({qmlProjectSourceId, qtQuickProjectSourceId}),
UnorderedElementsAre(projectData1));
ASSERT_THAT(storage.fetchDirectoryInfos({qmlProjectSourceId, qtQuickProjectSourceId}),
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,
qmlModuleId,
Storage::Synchronization::FileType::QmlDocument};
Storage::Synchronization::ProjectData projectData2{qmlProjectSourceId,
Storage::Synchronization::DirectoryInfo directoryInfo2{qmlProjectSourceId,
sourceId2,
qmlModuleId,
Storage::Synchronization::FileType::QmlDocument};
Storage::Synchronization::ProjectData projectData2b{qmlProjectSourceId,
Storage::Synchronization::DirectoryInfo directoryInfo2b{qmlProjectSourceId,
sourceId2,
qmlModuleId,
Storage::Synchronization::FileType::QmlTypes};
Storage::Synchronization::ProjectData projectData3{qtQuickProjectSourceId,
Storage::Synchronization::DirectoryInfo directoryInfo3{qtQuickProjectSourceId,
sourceId3,
qtQuickModuleId,
Storage::Synchronization::FileType::QmlTypes};
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}),
UnorderedElementsAre(projectData1, projectData2b, projectData3));
ASSERT_THAT(storage.fetchDirectoryInfos({qmlProjectSourceId, qtQuickProjectSourceId}),
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,
qmlModuleId,
Storage::Synchronization::FileType::QmlDocument};
Storage::Synchronization::ProjectData projectData2{qmlProjectSourceId,
Storage::Synchronization::DirectoryInfo directoryInfo2{qmlProjectSourceId,
sourceId3,
qmlModuleId,
Storage::Synchronization::FileType::QmlDocument};
Storage::Synchronization::ProjectData projectData2b{qmlProjectSourceId,
Storage::Synchronization::DirectoryInfo directoryInfo2b{qmlProjectSourceId,
sourceId3,
qtQuickModuleId,
Storage::Synchronization::FileType::QmlDocument};
Storage::Synchronization::ProjectData projectData3{qtQuickProjectSourceId,
Storage::Synchronization::DirectoryInfo directoryInfo3{qtQuickProjectSourceId,
sourceId2,
qtQuickModuleId,
Storage::Synchronization::FileType::QmlTypes};
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}),
UnorderedElementsAre(projectData1, projectData2b, projectData3));
ASSERT_THAT(storage.fetchDirectoryInfos({qmlProjectSourceId, qtQuickProjectSourceId}),
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{},
qmlModuleId,
Storage::Synchronization::FileType::QmlDocument};
ASSERT_THROW(storage.synchronize(SynchronizationPackage{{qmlProjectSourceId}, {projectData1}}),
QmlDesigner::ProjectDataHasInvalidSourceId);
ASSERT_THROW(storage.synchronize(SynchronizationPackage{{qmlProjectSourceId}, {directoryInfo1}}),
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,
ModuleId{},
Storage::Synchronization::FileType::QmlDocument};
storage.synchronize(SynchronizationPackage{{qmlProjectSourceId}, {projectData1}});
storage.synchronize(SynchronizationPackage{{qmlProjectSourceId}, {directoryInfo1}});
ASSERT_THAT(storage.fetchProjectDatas({qmlProjectSourceId, qtQuickProjectSourceId}),
UnorderedElementsAre(projectData1));
ASSERT_THAT(storage.fetchDirectoryInfos({qmlProjectSourceId, qtQuickProjectSourceId}),
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,
qmlModuleId,
Storage::Synchronization::FileType::QmlDocument};
storage.synchronize(SynchronizationPackage{{qmlProjectSourceId}, {projectData1}});
projectData1.moduleId = ModuleId{};
storage.synchronize(SynchronizationPackage{{qmlProjectSourceId}, {directoryInfo1}});
directoryInfo1.moduleId = ModuleId{};
storage.synchronize(SynchronizationPackage{{qmlProjectSourceId}, {projectData1}});
storage.synchronize(SynchronizationPackage{{qmlProjectSourceId}, {directoryInfo1}});
ASSERT_THAT(storage.fetchProjectDatas({qmlProjectSourceId, qtQuickProjectSourceId}),
UnorderedElementsAre(projectData1));
ASSERT_THAT(storage.fetchDirectoryInfos({qmlProjectSourceId, qtQuickProjectSourceId}),
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,
qmlModuleId,
Storage::Synchronization::FileType::QmlDocument};
ASSERT_THROW(storage.synchronize(SynchronizationPackage{{qmlProjectSourceId}, {projectData1}}),
QmlDesigner::ProjectDataHasInvalidProjectSourceId);
ASSERT_THROW(storage.synchronize(SynchronizationPackage{{qmlProjectSourceId}, {directoryInfo1}}),
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,
qmlModuleId,
Storage::Synchronization::FileType::QmlDocument};
Storage::Synchronization::ProjectData projectData2{qmlProjectSourceId,
Storage::Synchronization::DirectoryInfo directoryInfo2{qmlProjectSourceId,
sourceId2,
qmlModuleId,
Storage::Synchronization::FileType::QmlDocument};
Storage::Synchronization::ProjectData projectData3{qtQuickProjectSourceId,
Storage::Synchronization::DirectoryInfo directoryInfo3{qtQuickProjectSourceId,
sourceId3,
qtQuickModuleId,
Storage::Synchronization::FileType::QmlTypes};
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,
qmlModuleId,
Storage::Synchronization::FileType::QmlDocument};
Storage::Synchronization::ProjectData projectData2{qmlProjectSourceId,
Storage::Synchronization::DirectoryInfo directoryInfo2{qmlProjectSourceId,
sourceId2,
qmlModuleId,
Storage::Synchronization::FileType::QmlDocument};
Storage::Synchronization::ProjectData projectData3{qtQuickProjectSourceId,
Storage::Synchronization::DirectoryInfo directoryInfo3{qtQuickProjectSourceId,
sourceId3,
qtQuickModuleId,
Storage::Synchronization::FileType::QmlTypes};
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,
qmlModuleId,
Storage::Synchronization::FileType::QmlDocument};
Storage::Synchronization::ProjectData projectData2{qmlProjectSourceId,
Storage::Synchronization::DirectoryInfo directoryInfo2{qmlProjectSourceId,
sourceId2,
qmlModuleId,
Storage::Synchronization::FileType::QmlDocument};
Storage::Synchronization::ProjectData projectData3{qtQuickProjectSourceId,
Storage::Synchronization::DirectoryInfo directoryInfo3{qtQuickProjectSourceId,
sourceId3,
qtQuickModuleId,
Storage::Synchronization::FileType::QmlTypes};
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)

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