qt/qttools/src/qtattributionsscanner/scanner.cpp

Revision control

++ // Copyright (C) 2016 The Qt Company Ltd.
++ // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
++
++ #include "scanner.h"
++ #include "logging.h"
++
++ #include <QtCore/qdir.h>
++ #include <QtCore/qhash.h>
++ #include <QtCore/qjsonarray.h>
++ #include <QtCore/qjsondocument.h>
++ #include <QtCore/qjsonobject.h>
++ #include <QtCore/qtextstream.h>
++ #include <QtCore/qvariant.h>
++
++ #include <iostream>
++
++ using namespace Qt::Literals::StringLiterals;
++
++ namespace Scanner {
++
++ static void missingPropertyWarning(const QString &filePath, const QString &property)
++ {
++ std::cerr << qPrintable(tr("File %1: Missing mandatory property '%2'.").arg(
++ QDir::toNativeSeparators(filePath), property)) << std::endl;
++ }
++
++ bool validatePackage(Package &p, Checks checks, LogLevel logLevel)
++ {
++ const auto &filePath = p.filePath;
++ bool validPackage = true;
++
++ if (filePath.isEmpty()) {
++ std::cerr << qPrintable(tr("The origin file of package '%1' was not recorded.")
++ .arg(p.id));
++ return false;
++ }
++
++ if (p.qtParts.isEmpty())
++ p.qtParts << u"libs"_s;
++
++ if (p.name.isEmpty()) {
++ if (p.id.startsWith("chromium-"_L1)) // Ignore invalid README.chromium files
++ return false;
++
++ if (logLevel != SilentLog)
++ missingPropertyWarning(filePath, u"Name"_s);
++ validPackage = false;
++ }
++
++ if (p.id.isEmpty()) {
++ if (logLevel != SilentLog)
++ missingPropertyWarning(filePath, u"Id"_s);
++ validPackage = false;
++ } else if (!p.id.isLower() || p.id.contains(' '_L1)) {
++ if (logLevel != SilentLog)
++ std::cerr << qPrintable(tr("File %1: Value of 'Id' must be in lowercase and without spaces.")
++ .arg(QDir::toNativeSeparators(filePath))) << std::endl;
++ validPackage = false;
++ }
++
++ if (p.license.isEmpty()) {
++ if (logLevel != SilentLog)
++ missingPropertyWarning(filePath, u"License"_s);
++ validPackage = false;
++ }
++
++ if (!p.copyright.isEmpty() && !p.copyrightFile.isEmpty()) {
++ if (logLevel != SilentLog) {
++ std::cerr << qPrintable(tr("File %1: Properties 'Copyright' and 'CopyrightFile' are "
++ "mutually exclusive.")
++ .arg(QDir::toNativeSeparators(filePath)))
++ << std::endl;
++ }
++ validPackage = false;
++ }
++
++ if (p.securityCritical && p.downloadLocation.isEmpty()) {
++ if (logLevel != SilentLog)
++ missingPropertyWarning(filePath, u"DownloadLocation"_s);
++ validPackage = false;
++ }
++
++ for (const QString &part : std::as_const(p.qtParts)) {
++ if (part != "examples"_L1 && part != "tests"_L1
++ && part != "tools"_L1 && part != "libs"_L1) {
++
++ if (logLevel != SilentLog) {
++ std::cerr << qPrintable(tr("File %1: Property 'QtPart' contains unknown element "
++ "'%2'. Valid entries are 'examples', 'tests', 'tools' "
++ "and 'libs'.").arg(
++ QDir::toNativeSeparators(filePath), part))
++ << std::endl;
++ }
++ validPackage = false;
++ }
++ }
++
++ if (p.origin == Package::Origin::Provisioned && !p.files.isEmpty()) {
++ std::cerr << qPrintable(tr("File %1: Do not set property 'Files' if property "
++ "'Origin' is set to 'Provisioned'.")
++ .arg(QDir::toNativeSeparators(filePath)))
++ << std::endl;
++
++ validPackage = false;
++ }
++
++ if (!(checks & Check::Paths))
++ return validPackage;
++
++ const QDir dir = p.path;
++ if (!dir.exists()) {
++ std::cerr << qPrintable(
++ tr("File %1: Directory '%2' does not exist.")
++ .arg(QDir::toNativeSeparators(filePath), QDir::toNativeSeparators(p.path)))
++ << std::endl;
++ validPackage = false;
++ } else {
++ for (const QString &file : std::as_const(p.files)) {
++ if (!dir.exists(file)) {
++ if (logLevel != SilentLog) {
++ std::cerr << qPrintable(
++ tr("File %1: Path '%2' does not exist in directory '%3'.")
++ .arg(QDir::toNativeSeparators(filePath),
++ QDir::toNativeSeparators(file),
++ QDir::toNativeSeparators(p.path)))
++ << std::endl;
++ }
++ validPackage = false;
++ }
++ }
++ }
++
++ return validPackage;
++ }
++
++ static std::optional<QStringList> toStringList(const QJsonValue &value)
++ {
++ if (!value.isArray())
++ return std::nullopt;
++ QStringList result;
++ for (const auto &iter : value.toArray()) {
++ if (iter.type() != QJsonValue::String)
++ return std::nullopt;
++ result.push_back(iter.toString());
++ }
++ return result;
++ }
++
++ static std::optional<QString> arrayToMultiLineString(const QJsonValue &value)
++ {
++ if (!value.isArray())
++ return std::nullopt;
++ QString result;
++ for (const auto &iter : value.toArray()) {
++ if (iter.type() != QJsonValue::String)
++ return std::nullopt;
++ result.append(iter.toString());
++ result.append(QLatin1StringView("\n"));
++ }
++ return result;
++ }
++
++ // Extracts SPDX license ids from a SPDX license expression.
++ // For "(BSD-3-Clause AND BeerWare)" this function returns { "BSD-3-Clause", "BeerWare" }.
++ static QStringList extractLicenseIdsFromSPDXExpression(QString expression)
++ {
++ const QStringList spdxOperators = {
++ u"AND"_s,
++ u"OR"_s,
++ u"WITH"_s
++ };
++
++ // Replace parentheses with spaces. We're not interested in grouping.
++ const QRegularExpression parensRegex(u"[()]"_s);
++ expression.replace(parensRegex, u" "_s);
++
++ // Split the string at space boundaries to extract tokens.
++ QStringList result;
++ for (const QString &token : expression.split(QLatin1Char(' '), Qt::SkipEmptyParts)) {
++ if (spdxOperators.contains(token))
++ continue;
++
++ // Remove the unary + operator, if present.
++ if (token.endsWith(QLatin1Char('+')))
++ result.append(token.mid(0, token.size() - 1));
++ else
++ result.append(token);
++ }
++ return result;
++ }
++
++ // Starting at packageDir, look for a LICENSES subdirectory in the directory hierarchy upwards.
++ // Return a default-constructed QString if the directory was not found.
++ static QString locateLicensesDir(const QString &packageDir)
++ {
++ static const QString licensesSubDir = u"LICENSES"_s;
++ QDir dir(packageDir);
++ while (true) {
++ if (!dir.exists())
++ break;
++ if (dir.cd(licensesSubDir))
++ return dir.path();
++ if (dir.isRoot() || !dir.cdUp())
++ break;
++ }
++ return {};
++ }
++
++ // Locates the license files that belong to the licenses mentioned in LicenseId and stores them in
++ // the specified package object.
++ static bool autoDetectLicenseFiles(Package &p)
++ {
++ const QString licensesDirPath = locateLicensesDir(p.path);
++ const QStringList licenseIds = extractLicenseIdsFromSPDXExpression(p.licenseId);
++
++ bool success = true;
++ QDir licensesDir(licensesDirPath);
++ QDir licensesDirLocal = p.path;
++ for (const QString &id : licenseIds) {
++ QString fileName = id + u".txt";
++ QString fileNameLocal = u"LICENSE." + id + u".txt";
++
++ if (licensesDirLocal.exists(fileNameLocal)) {
++ p.licenseFiles.append(licensesDirLocal.filePath(fileNameLocal));
++ } else if (licensesDir.exists(fileName)) {
++ p.licenseFiles.append(licensesDir.filePath(fileName));
++ } else {
++ std::cerr << qPrintable(tr("Missing expected license file:")) << std::endl;
++ std::cerr << qPrintable(QDir::toNativeSeparators(licensesDirLocal.filePath(fileNameLocal)))
++ << std::endl;
++ if (!licensesDirPath.isEmpty()) {
++ std::cerr << qPrintable(tr("or\n %1").arg(
++ QDir::toNativeSeparators(licensesDir.filePath(fileName))))
++ << std::endl;
++ }
++ success = false;
++ }
++ }
++
++ return success;
++ }
++
++ // Tries to interpret a json value either as a string or an array of strings, and assigns the
++ // result to outList. Returns true on success, false on failure. On failure, it also conditionally
++ // prints an error.
++ static bool handleStringOrStringArrayJsonKey(QStringList &outList, const QString &key,
++ QJsonValueConstRef jsonValue, const QString &filePath,
++ LogLevel logLevel)
++ {
++ if (jsonValue.isArray()) {
++ auto maybeStringList = toStringList(jsonValue);
++ if (maybeStringList)
++ outList = maybeStringList.value();
++ } else if (jsonValue.isString()) {
++ outList.append(jsonValue.toString());
++ } else {
++ if (logLevel != SilentLog) {
++ std::cerr << qPrintable(tr("File %1: Expected JSON array of strings or "
++ "string as value of %2.").arg(
++ QDir::toNativeSeparators(filePath), key))
++ << std::endl;
++ }
++ return false;
++ }
++ return true;
++ }
++
++ // Transforms a JSON object into a Package object
++ static std::optional<Package> readPackage(const QJsonObject &object, const QString &filePath,
++ LogLevel logLevel)
++ {
++ Package p;
++ bool validPackage = true;
++ const QString directory = QFileInfo(filePath).absolutePath();
++ p.filePath = QFileInfo(filePath).absoluteFilePath();
++ p.path = directory;
++
++ for (auto iter = object.constBegin(); iter != object.constEnd(); ++iter) {
++ const QString key = iter.key();
++
++ if (!iter.value().isString() && key != "QtParts"_L1 && key != "SecurityCritical"_L1
++ && key != "Files"_L1 && key != "LicenseFiles"_L1 && key != "Comment"_L1
++ && key != "Copyright"_L1 && key != "CPE"_L1 && key != "PURL"_L1) {
++ if (logLevel != SilentLog)
++ std::cerr << qPrintable(tr("File %1: Expected JSON string as value of %2.").arg(
++ QDir::toNativeSeparators(filePath), key)) << std::endl;
++ validPackage = false;
++ continue;
++ }
++ const QString value = iter.value().toString();
++ if (key == "Name"_L1) {
++ p.name = value;
++ } else if (key == "Path"_L1) {
++ p.path = QDir(directory).absoluteFilePath(value);
++ } else if (key == "Files"_L1) {
++ QJsonValueConstRef jsonValue = iter.value();
++ if (jsonValue.isArray()) {
++ auto maybeStringList = toStringList(jsonValue);
++ if (maybeStringList)
++ p.files = maybeStringList.value();
++ } else if (jsonValue.isString()) {
++ // Legacy format: multiple values separated by space in one string.
++ p.files = value.simplified().split(QLatin1Char(' '), Qt::SkipEmptyParts);
++ } else {
++ if (logLevel != SilentLog) {
++ std::cerr << qPrintable(tr("File %1: Expected JSON array of strings as value "
++ "of Files.").arg(QDir::toNativeSeparators(filePath)))
++ << std::endl;
++ validPackage = false;
++ continue;
++ }
++ }
++ } else if (key == "Comment"_L1) {
++ // Accepted purely to record details of potential interest doing
++ // updates in future. Value is an arbitrary object. Any number of
++ // Comment entries may be present: JSON doesn't require names to be
++ // unique, albeit some linters may kvetch.
++ } else if (key == "Id"_L1) {
++ p.id = value;
++ } else if (key == "Origin"_L1) {
++ if (value == "InSource"_L1) {
++ p.origin = Package::Origin::InSource;
++ } else if (value == "Provisioned"_L1) {
++ p.origin = Package::Origin::Provisioned;
++ } else {
++ std::cerr << qPrintable(tr("File %1: Expected either 'InSource' or 'Provisioned'"
++ " as value of 'Origin'.")
++ .arg(QDir::toNativeSeparators(filePath)))
++ << std::endl;
++ validPackage = false;
++ continue;
++ }
++ } else if (key == "Homepage"_L1) {
++ p.homepage = value;
++ } else if (key == "Version"_L1) {
++ p.version = value;
++ } else if (key == "DownloadLocation"_L1) {
++ p.downloadLocation = value;
++ } else if (key == "License"_L1) {
++ p.license = value;
++ } else if (key == "LicenseId"_L1) {
++ p.licenseId = value;
++ } else if (key == "LicenseFile"_L1) {
++ p.licenseFiles = QStringList(QDir(directory).absoluteFilePath(value));
++ } else if (key == "LicenseFiles"_L1) {
++ auto strings = toStringList(iter.value());
++ if (!strings) {
++ if (logLevel != SilentLog)
++ std::cerr << qPrintable(tr("File %1: Expected JSON array of strings in %2.")
++ .arg(QDir::toNativeSeparators(filePath), key))
++ << std::endl;
++ validPackage = false;
++ continue;
++ }
++ const QDir dir(directory);
++ for (const auto &iter : std::as_const(strings.value()))
++ p.licenseFiles.push_back(dir.absoluteFilePath(iter));
++ } else if (key == "Copyright"_L1) {
++ QJsonValueConstRef jsonValue = iter.value();
++ if (jsonValue.isArray()) {
++ // Array joined with new lines
++ auto maybeString = arrayToMultiLineString(jsonValue);
++ if (maybeString)
++ p.copyright = maybeString.value();
++ } else if (jsonValue.isString()) {
++ // Legacy format: multiple values separated by space in one string.
++ p.copyright = value;
++ } else {
++ if (logLevel != SilentLog) {
++ std::cerr << qPrintable(tr("File %1: Expected JSON array of strings or "
++ "string as value of %2.").arg(
++ QDir::toNativeSeparators(filePath), key)) << std::endl;
++ validPackage = false;
++ continue;
++ }
++ }
++ } else if (key == "CPE"_L1) {
++ const QJsonValueConstRef jsonValue = iter.value();
++ if (!handleStringOrStringArrayJsonKey(p.cpeList, key, jsonValue, filePath, logLevel)) {
++ validPackage = false;
++ continue;
++ }
++ } else if (key == "PURL"_L1) {
++ const QJsonValueConstRef jsonValue = iter.value();
++ if (!handleStringOrStringArrayJsonKey(p.purlList, key, jsonValue, filePath, logLevel)) {
++ validPackage = false;
++ continue;
++ }
++ } else if (key == "CopyrightFile"_L1) {
++ p.copyrightFile = QDir(directory).absoluteFilePath(value);
++ } else if (key == "PackageComment"_L1) {
++ p.packageComment = value;
++ } else if (key == "QDocModule"_L1) {
++ p.qdocModule = value;
++ } else if (key == "Description"_L1) {
++ p.description = value;
++ } else if (key == "QtUsage"_L1) {
++ p.qtUsage = value;
++ } else if (key == "SecurityCritical"_L1) {
++ if (!iter.value().isBool()) {
++ std::cerr << qPrintable(tr("File %1: Expected JSON boolean in %2.")
++ .arg(QDir::toNativeSeparators(filePath), key))
++ << std::endl;
++ validPackage = false;
++ continue;
++ }
++ p.securityCritical = iter.value().toBool();
++ } else if (key == "QtParts"_L1) {
++ auto parts = toStringList(iter.value());
++ if (!parts) {
++ if (logLevel != SilentLog) {
++ std::cerr << qPrintable(tr("File %1: Expected JSON array of strings in %2.")
++ .arg(QDir::toNativeSeparators(filePath), key))
++ << std::endl;
++ }
++ validPackage = false;
++ continue;
++ }
++ p.qtParts = parts.value();
++ } else {
++ if (logLevel != SilentLog) {
++ std::cerr << qPrintable(tr("File %1: Unknown key %2.").arg(
++ QDir::toNativeSeparators(filePath), key)) << std::endl;
++ }
++ validPackage = false;
++ }
++ }
++
++ // Replace $<VERSION> and $<VERSION_DASHED> in string values
++ {
++ const QString versionVar = u"$<VERSION>"_s;
++ const QString versionDashedVar = u"$<VERSION_DASHED>"_s;
++ auto replaceInString = [&](QString &s) {
++ if (s.contains(versionVar) || s.contains(versionDashedVar)) {
++ if (p.version.isEmpty()) {
++ if (logLevel != SilentLog) {
++ std::cerr << qPrintable(
++ tr("File %1: $<VERSION> used but 'Version' is not set.")
++ .arg(QDir::toNativeSeparators(filePath)))
++ << std::endl;
++ }
++ validPackage = false;
++ return;
++ }
++ s.replace(versionVar, p.version);
++ s.replace(versionDashedVar,
++ QString(p.version).replace(u'.', u'-'));
++ }
++ };
++ auto replaceInList = [&](QStringList &list) {
++ for (QString &s : list)
++ replaceInString(s);
++ };
++ replaceInString(p.name);
++ replaceInString(p.homepage);
++ replaceInString(p.downloadLocation);
++ replaceInString(p.description);
++ replaceInString(p.qtUsage);
++ replaceInString(p.packageComment);
++ replaceInList(p.cpeList);
++ replaceInList(p.purlList);
++ }
++
++ if (!p.copyrightFile.isEmpty()) {
++ QFile file(p.copyrightFile);
++ if (!file.open(QIODevice::ReadOnly)) {
++ std::cerr << qPrintable(tr("File %1: Cannot open 'CopyrightFile' %2.\n")
++ .arg(QDir::toNativeSeparators(filePath),
++ QDir::toNativeSeparators(p.copyrightFile)));
++ validPackage = false;
++ }
++ p.copyrightFileContents = QString::fromUtf8(file.readAll());
++ }
++
++ if (p.licenseFiles.isEmpty() && !autoDetectLicenseFiles(p))
++ return std::nullopt;
++
++ for (const QString &licenseFile : std::as_const(p.licenseFiles)) {
++ QFile file(licenseFile);
++ if (!file.open(QIODevice::ReadOnly)) {
++ if (logLevel != SilentLog) {
++ std::cerr << qPrintable(tr("File %1: Cannot open 'LicenseFile' %2.\n")
++ .arg(QDir::toNativeSeparators(filePath),
++ QDir::toNativeSeparators(licenseFile)));
++ }
++ validPackage = false;
++ }
++ p.licenseFilesContents << QString::fromUtf8(file.readAll()).trimmed();
++ }
++
++ if (!validPackage)
++ return std::nullopt;
++
++ return p;
++ }
++
++ // Parses a package's details from a README.chromium file
++ static Package parseChromiumFile(QFile &file, const QString &filePath, LogLevel logLevel)
++ {
++ const QString directory = QFileInfo(filePath).absolutePath();
++
++ // Parse the fields in the file
++ QHash<QString, QString> fields;
++
++ QTextStream in(&file);
++ while (!in.atEnd()) {
++ QString line = in.readLine().trimmed();
++ QStringList parts = line.split(u":"_s);
++
++ if (parts.size() < 2)
++ continue;
++
++ QString key = parts.at(0);
++ parts.removeFirst();
++ QString value = parts.join(QString()).trimmed();
++
++ fields[key] = value;
++
++ if (line == "Description:"_L1) { // special field : should handle multi-lines values
++ while (!in.atEnd()) {
++ QString line = in.readLine().trimmed();
++
++ if (line.startsWith("Local Modifications:"_L1)) // Don't include this part
++ break;
++
++ fields[key] += line + u"\n"_s;
++ }
++
++ break;
++ }
++ }
++
++ // Construct the Package object
++ Package p;
++
++ QString shortName = fields.contains("Short Name"_L1)
++ ? fields["Short Name"_L1]
++ : fields["Name"_L1];
++ QString version = fields[u"Version"_s];
++
++ p.filePath = QFileInfo(filePath).absoluteFilePath();
++ p.id = u"chromium-"_s + shortName.toLower().replace(QChar::Space, u"-"_s);
++ p.name = fields[u"Name"_s];
++ if (version != QLatin1Char('0')) // "0" : not applicable
++ p.version = version;
++ p.license = fields[u"License"_s];
++ p.homepage = fields[u"URL"_s];
++ p.qdocModule = u"qtwebengine"_s;
++ p.qtUsage = u"Used in Qt WebEngine"_s;
++ p.description = fields[u"Description"_s].trimmed();
++ p.path = directory;
++
++ QString licenseFile = fields[u"License File"_s];
++ if (licenseFile != QString() && licenseFile != "NOT_SHIPPED"_L1) {
++ p.licenseFiles = QStringList(QDir(directory).absoluteFilePath(licenseFile));
++ } else {
++ // Look for a LICENSE or COPYING file as a fallback
++ QDir dir = directory;
++
++ dir.setNameFilters({ u"LICENSE"_s, u"COPYING"_s });
++ dir.setFilter(QDir::Files | QDir::NoDotAndDotDot);
++
++ const QFileInfoList entries = dir.entryInfoList();
++ if (!entries.empty())
++ p.licenseFiles = QStringList(entries.at(0).absoluteFilePath());
++ }
++
++ // let's ignore warnings regarding Chromium files for now
++ Q_UNUSED(validatePackage(p, {}, logLevel));
++
++ return p;
++ }
++
++ struct CursorPosition
++ {
++ int line = -1;
++ int column = -1;
++ };
++
++ static CursorPosition mapFromOffset(const QByteArray &content, int offset)
++ {
++ CursorPosition pos{ 1, 1 };
++ for (int i = 0; i < content.size(); ++i) {
++ if (i == offset)
++ return pos;
++
++ if (content[i] == '\n') {
++ pos.line++;
++ pos.column = 1;
++ } else {
++ pos.column++;
++ }
++ }
++ return CursorPosition();
++ }
++
++ std::optional<QList<Package>> readFile(const QString &filePath, LogLevel logLevel)
++ {
++ QList<Package> packages;
++ bool errorsFound = false;
++
++ if (logLevel == VerboseLog) {
++ std::cerr << qPrintable(tr("Reading file %1...").arg(
++ QDir::toNativeSeparators(filePath))) << std::endl;
++ }
++ QFile file(filePath);
++ if (!file.open(QIODevice::ReadOnly | QIODevice::Text)) {
++ if (logLevel != SilentLog)
++ std::cerr << qPrintable(tr("Could not open file %1.").arg(
++ QDir::toNativeSeparators(file.fileName()))) << std::endl;
++ return std::nullopt;
++ }
++
++ if (filePath.endsWith(".json"_L1)) {
++ QJsonParseError jsonParseError;
++ const QByteArray content = file.readAll();
++ const QJsonDocument document = QJsonDocument::fromJson(content, &jsonParseError);
++ if (document.isNull()) {
++ if (logLevel != SilentLog) {
++ const CursorPosition pos = mapFromOffset(content, jsonParseError.offset);
++ std::cerr << qPrintable(tr("Could not parse file %1: %2 at line %3, column %4")
++ .arg(QDir::toNativeSeparators(file.fileName()),
++ jsonParseError.errorString(),
++ QString::number(pos.line),
++ QString::number(pos.column)))
++ << std::endl;
++ }
++ return std::nullopt;
++ }
++
++ if (document.isObject()) {
++ std::optional<Package> p =
++ readPackage(document.object(), file.fileName(), logLevel);
++ if (p) {
++ packages << *p;
++ } else {
++ errorsFound = true;
++ }
++ } else if (document.isArray()) {
++ QJsonArray array = document.array();
++ for (int i = 0, size = array.size(); i < size; ++i) {
++ QJsonValue value = array.at(i);
++ if (value.isObject()) {
++ std::optional<Package> p =
++ readPackage(value.toObject(), file.fileName(), logLevel);
++ if (p) {
++ packages << *p;
++ } else {
++ errorsFound = true;
++ }
++ } else {
++ if (logLevel != SilentLog) {
++ std::cerr << qPrintable(tr("File %1: Expecting JSON object in array.")
++ .arg(QDir::toNativeSeparators(file.fileName())))
++ << std::endl;
++ }
++ errorsFound = true;
++ }
++ }
++ } else {
++ if (logLevel != SilentLog) {
++ std::cerr << qPrintable(tr("File %1: Expecting JSON object in array.").arg(
++ QDir::toNativeSeparators(file.fileName()))) << std::endl;
++ }
++ errorsFound = true;
++ }
++ } else if (filePath.endsWith(".chromium"_L1)) {
++ Package chromiumPackage = parseChromiumFile(file, filePath, logLevel);
++ if (!chromiumPackage.name.isEmpty()) // Skip invalid README.chromium files
++ packages << chromiumPackage;
++ } else {
++ if (logLevel != SilentLog) {
++ std::cerr << qPrintable(tr("File %1: Unsupported file type.")
++ .arg(QDir::toNativeSeparators(file.fileName())))
++ << std::endl;
++ }
++ errorsFound = true;
++ }
++
++ if (errorsFound)
++ return std::nullopt;
++ return packages;
++ }
++
++ std::optional<QList<Package>> scanDirectory(const QString &directory, InputFormats inputFormats,
++ LogLevel logLevel)
++ {
++ QDir dir(directory);
++ QList<Package> packages;
++ bool errorsFound = false;
++
++ QStringList nameFilters = QStringList();
++ if (inputFormats & InputFormat::QtAttributions)
++ nameFilters << u"qt_attribution.json"_s;
++ if (inputFormats & InputFormat::ChromiumAttributions)
++ nameFilters << u"README.chromium"_s;
++ if (qEnvironmentVariableIsSet("QT_ATTRIBUTIONSSCANNER_TEST"))
++ nameFilters << u"qt_attribution_test.json"_s << u"README_test.chromium"_s;
++
++ dir.setNameFilters(nameFilters);
++ dir.setFilter(QDir::AllDirs | QDir::NoDotAndDotDot | QDir::Files);
++
++ const QFileInfoList entries = dir.entryInfoList();
++ for (const QFileInfo &info : entries) {
++ if (info.isDir()) {
++ std::optional<QList<Package>> ps =
++ scanDirectory(info.filePath(), inputFormats, logLevel);
++ if (!ps)
++ errorsFound = true;
++ else
++ packages += *ps;
++ } else {
++ std::optional p = readFile(info.filePath(), logLevel);
++ if (!p)
++ errorsFound = true;
++ else
++ packages += *p;
++ }
++ }
++
++ if (errorsFound)
++ return std::nullopt;
++ return packages;
++ }
++
++ } // namespace Scanner