Revision control
Copy as Markdown
// 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;
}