Revision control
++ // Copyright (C) 2021 The Qt Company Ltd.
++ // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
++ // Qt-Security score:significant
++
++ #include "qqmltoolingsettings_p.h"
++
++ #include <QtCore/qdebug.h>
++ #include <QtCore/qdir.h>
++ #include <QtCore/qfileinfo.h>
++ #include <QtCore/qset.h>
++ #include <QtCore/qtextstream.h>
++ #if QT_CONFIG(settings)
++ #include <QtCore/qsettings.h>
++ #endif
++ #include <QtCore/qstandardpaths.h>
++
++ using namespace Qt::StringLiterals;
++
++ QQmlToolingSettings::SearchOptions::SearchOptions() = default;
++ QQmlToolingSettings::SearchOptions::SearchOptions(
++ const QString &settingFileName, bool reportFoundSettingsFiles, bool isQmllintSilent)
++ : settingsFileName(settingFileName), reportFoundSettingsFiles(reportFoundSettingsFiles),
++ isQmllintSilent(isQmllintSilent)
++ {
++
++ }
++
++ void QQmlToolingSettings::addOption(const QString &name, const QVariant &defaultValue)
++ {
++ if (defaultValue.isValid()) {
++ m_values[name] = defaultValue;
++ }
++ }
++
++ QQmlToolingSettings::QQmlToolingSettings(const QString &toolName,
++ const QStringList &recognizedIniSections,
++ const QString &localSettingsFile,
++ const QString &globalSettingsFile)
++ : m_searcher(localSettingsFile.isEmpty() ? u".%1.ini"_s.arg(toolName) : localSettingsFile,
++ globalSettingsFile.isEmpty() ? u"%1.ini"_s.arg(toolName) : globalSettingsFile),
++ m_recognizedIniSections(recognizedIniSections)
++ {
++ }
++
++ QQmlToolingSettings::SearchResult QQmlToolingSettings::read(const QString &settingsFilePath,
++ SearchOptions options)
++ {
++ #if QT_CONFIG(settings)
++ Q_ASSERT(QFileInfo::exists(settingsFilePath));
++
++ if (m_currentSettingsPath == settingsFilePath)
++ return { SearchResult::ResultType::Found, settingsFilePath };
++
++ QSettings settings(settingsFilePath, QSettings::IniFormat);
++
++ if (!options.isQmllintSilent && !m_recognizedIniSections.isEmpty()) {
++ const QStringList sections = settings.childGroups() << QLatin1String("General");
++ for (const QString §ion : sections) {
++ if (!m_recognizedIniSections.contains(section)) {
++ qWarning().noquote()
++ << "Unrecognized section \"%1\" in %2\n"_L1.arg(section).arg(settingsFilePath)
++ + "Recognized sections are: ["_L1
++ + m_recognizedIniSections.join(", "_L1) + u']';
++ }
++ }
++ }
++
++ for (const QString &key : settings.allKeys())
++ m_values[key] = settings.value(key).toString();
++
++ m_currentSettingsPath = settingsFilePath;
++ return { SearchResult::ResultType::Found, settingsFilePath };
++ #else
++ Q_UNUSED(settingsFilePath);
++ return SearchResult();
++ #endif
++ }
++
++ bool QQmlToolingSettings::writeDefaults() const
++ {
++ #if QT_CONFIG(settings)
++ const QString path = QFileInfo(m_searcher.localSettingsFile()).absoluteFilePath();
++
++ QSettings settings(path, QSettings::IniFormat);
++ for (auto it = m_values.constBegin(); it != m_values.constEnd(); ++it) {
++ settings.setValue(it.key(), it.value().isNull() ? QString() : it.value());
++ }
++
++ settings.sync();
++
++ if (settings.status() != QSettings::NoError) {
++ qWarning() << "Failed to write default settings to" << path
++ << "Error:" << settings.status();
++ return false;
++ }
++
++ qInfo() << "Wrote default settings to" << path;
++ return true;
++ #else
++ return false;
++ #endif
++ }
++
++ QQmlToolingSettings::SearchResult
++ QQmlToolingSettings::Searcher::searchCurrentDirInCache(const QString &dirPath)
++ {
++ const auto it = m_seenDirectories.constFind(dirPath);
++ return it != m_seenDirectories.constEnd()
++ ? SearchResult{ SearchResult::ResultType::Found, *it }
++ : SearchResult{ SearchResult::ResultType::NotFound, {} };
++ }
++
++ static QString findIniFile(const QString &local, const QString &global)
++ {
++ // If we reach here, we didn't find the settings file in the current directory or any parent
++ // directories. Now we will try to locate the settings file in the standard locations. First try
++ // to locate settings file with the standard name.
++ const QString iniFile = QStandardPaths::locate(QStandardPaths::GenericConfigLocation, local);
++ if (!iniFile.isEmpty())
++ return iniFile;
++
++ // If not found, try alternate name format
++ return QStandardPaths::locate(QStandardPaths::GenericConfigLocation, global);
++ }
++
++ QQmlToolingSettings::SearchResult
++ QQmlToolingSettings::Searcher::searchDefaultLocation(const QSet<QString> *visitedDirs)
++ {
++ QString iniFile = findIniFile(m_localSettingsFile, m_globalSettingsFile);
++
++ // Update the seen directories cache unconditionally with the current result
++ for (const QString &dir : *visitedDirs)
++ m_seenDirectories[dir] = iniFile;
++
++ const SearchResult::ResultType found = iniFile.isEmpty()
++ ? SearchResult::ResultType::NotFound
++ : SearchResult::ResultType::Found;
++ return SearchResult { found, std::move(iniFile) };
++ }
++
++ QQmlToolingSettings::SearchResult
++ QQmlToolingSettings::Searcher::searchDirectoryHierarchy(
++ QSet<QString> *visitedDirs, const QString &path)
++ {
++ const QFileInfo fileInfo(path);
++ QDir dir(fileInfo.isDir() ? path : fileInfo.dir());
++
++ while (dir.exists() && dir.isReadable()) {
++ const QString dirPath = dir.absolutePath();
++
++ // Check if we have already seen this directory
++ // If we have, we can use the cached INI file path
++ // to avoid unnecessary file system operations
++ // This is useful for large directory trees where the settings file might be in a parent
++ // directory
++ if (const SearchResult result = searchCurrentDirInCache(dirPath); result.isValid())
++ return result;
++
++ visitedDirs->insert(dirPath);
++
++ // Check if the settings file exists in the current directory
++ // If it does, read it and update the seen directories cache
++ if (QString ini = dir.absoluteFilePath(m_localSettingsFile); QFileInfo::exists(ini)) {
++ for (const QString &visitedDir : std::as_const(*visitedDirs))
++ m_seenDirectories[visitedDir] = ini;
++
++ return { SearchResult::ResultType::Found, std::move(ini) };
++ }
++
++ if (!dir.cdUp())
++ break;
++ }
++
++ return SearchResult();
++ }
++
++ QQmlToolingSettings::SearchResult QQmlToolingSettings::Searcher::search(const QString &path)
++ {
++ QSet<QString> visitedDirs;
++
++ // Try to find settings in directory hierarchy
++ if (const SearchResult result = searchDirectoryHierarchy(&visitedDirs, path); result.isValid())
++ return result;
++
++ // If we didn't find the settings file in the current directory or any parent directories,
++ // try to locate the settings file in the standard locations
++ if (const SearchResult result = searchDefaultLocation(&visitedDirs); result.isValid())
++ return result;
++
++ return SearchResult();
++ }
++
++ QQmlToolingSettings::SearchResult QQmlToolingSettings::search(
++ const QString &path, const SearchOptions &options)
++ {
++ const auto maybeReport = qScopeGuard([&]() {
++ if (options.reportFoundSettingsFiles)
++ reportConfigForFiles({ path });
++ });
++
++ // If a specific settings file is provided, read it directly
++ if (!options.settingsFileName.isEmpty()) {
++ QFileInfo fileInfo(options.settingsFileName);
++ return fileInfo.exists() ? read(fileInfo.absoluteFilePath(), options) : SearchResult();
++ }
++
++ if (const SearchResult result = m_searcher.search(path); result.isValid())
++ return read(result.iniFilePath, options);
++
++ return SearchResult();
++ }
++
++ void QQmlToolingSettings::setValue(const QString &name, QVariant value)
++ {
++ m_values[name] = value;
++ }
++
++ QVariant QQmlToolingSettings::value(const QString &name) const
++ {
++ return m_values.value(name);
++ }
++
++ QStringList QQmlToolingSettings::valueAsStringList(const QString &name) const
++ {
++ return value(name).toString().split(QDir::listSeparator());
++ }
++
++ void QQmlToolingSettings::resolveRelativeImportPaths(const QString &filePath, QStringList *paths)
++ {
++ // transform relative paths in absolute paths starting from filePath's directory
++ const QDir fileDir = QFileInfo(filePath).absoluteDir();
++ for (auto it = paths->begin(), end = paths->end(); it != end; ++it) {
++ if (QFileInfo(*it).isAbsolute())
++ continue;
++ *it = QDir::cleanPath(fileDir.filePath(*it));
++ }
++ }
++
++ QStringList QQmlToolingSettings::valueAsAbsolutePathList(const QString &name,
++ const QString &baseForRelativePaths) const
++ {
++ QStringList paths = valueAsStringList(name);
++ resolveRelativeImportPaths(baseForRelativePaths, &paths);
++ return paths;
++ }
++
++ bool QQmlToolingSettings::isSet(const QString &name) const
++ {
++ if (!m_values.contains(name))
++ return false;
++
++ QVariant variant = m_values[name];
++
++ // Unset is encoded as an empty string
++ return !(variant.canConvert(QMetaType(QMetaType::QString)) && variant.toString().isEmpty());
++ }
++
++ bool QQmlToolingSettings::reportConfigForFiles(const QStringList &files)
++ {
++ constexpr int maxAllowedFileLength = 255;
++ constexpr int minAllowedFileLength = 40;
++ bool headerPrinted = false;
++ auto lengthForFile = [maxAllowedFileLength](const QString &file) {
++ return std::min(int(file.length()), maxAllowedFileLength);
++ };
++
++ int maxFileLength =
++ std::accumulate(files.begin(), files.end(), 0, [&](int acc, const QString &file) {
++ return std::max(acc, lengthForFile(file));
++ });
++
++ if (maxFileLength < minAllowedFileLength)
++ maxFileLength = minAllowedFileLength;
++
++ for (const auto &file : files) {
++ if (file.isEmpty()) {
++ qWarning().noquote() << "Error: Could not find file" << file;
++ return false;
++ }
++
++ QString displayFile = file;
++ if (displayFile.length() > maxAllowedFileLength) {
++ displayFile = u"..." + displayFile.right(maxAllowedFileLength - 3);
++ }
++
++ const auto result = m_searcher.search(file);
++
++ if (!headerPrinted) {
++ QString header =
++ QStringLiteral("%1 | %2").arg("File", -maxFileLength).arg("Settings File");
++ qWarning().noquote() << header;
++ qWarning().noquote() << QString(header.length(), u'-');
++ headerPrinted = true;
++ }
++ QString line =
++ QStringLiteral("%1 | %2").arg(displayFile, -maxFileLength).arg(result.iniFilePath);
++ qWarning().noquote() << line;
++ }
++
++ return true;
++ }