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
++ // Qt-Security score:insignificant reason:build-tool
++
++ #include "helpgenerator.h"
++ #include "qhelpprojectdata_p.h"
++ #include <qhelp_global.h>
++
++ #include <QtCore/QtMath>
++ #include <QtCore/QMap>
++ #include <QtCore/QFile>
++ #include <QtCore/QFileInfo>
++ #include <QtCore/QDir>
++ #include <QtCore/QDebug>
++ #include <QtCore/QRegularExpression>
++ #include <QtCore/QSet>
++ #include <QtCore/QMap>
++ #include <QtCore/QVariant>
++ #include <QtCore/QDateTime>
++ #include <QtCore/QStringConverter>
++ #include <QtCore/QDataStream>
++ #include <QtSql/QSqlQuery>
++
++ #include <stdio.h>
++
++ QT_BEGIN_NAMESPACE
++
++ class HelpGeneratorPrivate : public QObject
++ {
++ Q_OBJECT
++
++ public:
++ HelpGeneratorPrivate(QObject *parent = nullptr) : QObject(parent) {}
++
++ bool generate(QHelpProjectData *helpData,
++ const QString &outputFileName);
++ bool checkLinks(const QHelpProjectData &helpData);
++ QString error() const;
++
++ Q_SIGNALS:
++ void statusChanged(const QString &msg);
++ void progressChanged(double progress);
++ void warning(const QString &msg);
++
++ private:
++ struct FileNameTableData
++ {
++ QString name;
++ int fileId;
++ QString title;
++ };
++
++ void writeTree(QDataStream &s, QHelpDataContentItem *item, int depth);
++ bool createTables();
++ bool insertFileNotFoundFile();
++ bool registerCustomFilter(const QString &filterName,
++ const QStringList &filterAttribs, bool forceUpdate = false);
++ bool registerVirtualFolder(const QString &folderName, const QString &ns);
++ bool insertFilterAttributes(const QStringList &attributes);
++ bool insertKeywords(const QList<QHelpDataIndexItem> &keywords,
++ const QStringList &filterAttributes);
++ bool insertFiles(const QStringList &files, const QString &rootPath,
++ const QStringList &filterAttributes);
++ bool insertContents(const QByteArray &ba,
++ const QStringList &filterAttributes);
++ bool insertMetaData(const QMap<QString, QVariant> &metaData);
++ void cleanupDB();
++ void setupProgress(QHelpProjectData *helpData);
++ void addProgress(double step);
++
++ QString m_error;
++ QSqlQuery *m_query = nullptr;
++
++ int m_namespaceId = -1;
++ int m_virtualFolderId = -1;
++
++ QMap<QString, int> m_fileMap;
++ QMap<int, QSet<int> > m_fileFilterMap;
++
++ double m_progress;
++ double m_oldProgress;
++ double m_contentStep;
++ double m_fileStep;
++ double m_indexStep;
++ };
++
++ /*!
++ Takes the \a helpData and generates a new documentation
++ set from it. The Qt compressed help file is written to \a
++ outputFileName. Returns true on success, otherwise false.
++ */
++ bool HelpGeneratorPrivate::generate(QHelpProjectData *helpData,
++ const QString &outputFileName)
++ {
++ emit progressChanged(0);
++ m_error.clear();
++ if (!helpData || helpData->namespaceName().isEmpty()) {
++ m_error = tr("Invalid help data.");
++ return false;
++ }
++
++ QString outFileName = outputFileName;
++ if (outFileName.isEmpty()) {
++ m_error = tr("No output file name specified.");
++ return false;
++ }
++
++ QFileInfo fi(outFileName);
++ if (fi.exists()) {
++ if (!fi.dir().remove(fi.fileName())) {
++ m_error = tr("The file %1 cannot be overwritten.").arg(outFileName);
++ return false;
++ }
++ }
++
++ setupProgress(helpData);
++
++ emit statusChanged(tr("Building up file structure..."));
++ bool openingOk = true;
++ {
++ QSqlDatabase db = QSqlDatabase::addDatabase(QLatin1String("QSQLITE"), QLatin1String("builder"));
++ db.setDatabaseName(outFileName);
++ openingOk = db.open();
++ if (openingOk)
++ m_query = new QSqlQuery(db);
++ }
++
++ if (!openingOk) {
++ m_error = tr("Cannot open data base file %1.").arg(outFileName);
++ cleanupDB();
++ return false;
++ }
++
++ m_query->exec(QLatin1String("PRAGMA synchronous=OFF"));
++ m_query->exec(QLatin1String("PRAGMA cache_size=3000"));
++
++ addProgress(1.0);
++ createTables();
++ insertFileNotFoundFile();
++ insertMetaData(helpData->metaData());
++
++ if (!registerVirtualFolder(helpData->virtualFolder(), helpData->namespaceName())) {
++ m_error = tr("Cannot register namespace \"%1\".").arg(helpData->namespaceName());
++ cleanupDB();
++ return false;
++ }
++ addProgress(1.0);
++
++ emit statusChanged(tr("Insert custom filters..."));
++ for (const QHelpDataCustomFilter &f : helpData->customFilters()) {
++ if (!registerCustomFilter(f.name, f.filterAttributes, true)) {
++ cleanupDB();
++ return false;
++ }
++ }
++ addProgress(1.0);
++
++ int i = 1;
++ for (const QHelpDataFilterSection &fs : helpData->filterSections()) {
++ emit statusChanged(tr("Insert help data for filter section (%1 of %2)...")
++ .arg(i++).arg(helpData->filterSections().size()));
++ insertFilterAttributes(fs.filterAttributes());
++ QByteArray ba;
++ QDataStream s(&ba, QIODevice::WriteOnly);
++ for (QHelpDataContentItem *itm : fs.contents())
++ writeTree(s, itm, 0);
++ if (!insertFiles(fs.files(), helpData->rootPath(), fs.filterAttributes())
++ || !insertContents(ba, fs.filterAttributes())
++ || !insertKeywords(fs.indices(), fs.filterAttributes())) {
++ cleanupDB();
++ return false;
++ }
++ }
++
++ cleanupDB();
++ emit progressChanged(100);
++ emit statusChanged(tr("Documentation successfully generated."));
++ return true;
++ }
++
++ void HelpGeneratorPrivate::setupProgress(QHelpProjectData *helpData)
++ {
++ m_progress = 0;
++ m_oldProgress = 0;
++
++ int numberOfFiles = 0;
++ int numberOfIndices = 0;
++ for (const QHelpDataFilterSection &fs : helpData->filterSections()) {
++ numberOfFiles += fs.files().size();
++ numberOfIndices += fs.indices().size();
++ }
++ // init 2%
++ // filters 1%
++ // contents 10%
++ // files 60%
++ // indices 27%
++ m_contentStep = 10.0 / qMax(helpData->customFilters().size(), 1);
++ m_fileStep = 60.0 / qMax(numberOfFiles, 1);
++ m_indexStep = 27.0 / qMax(numberOfIndices, 1);
++ }
++
++ void HelpGeneratorPrivate::addProgress(double step)
++ {
++ m_progress += step;
++ if ((m_progress - m_oldProgress) >= 1.0 && m_progress <= 100.0) {
++ m_oldProgress = m_progress;
++ emit progressChanged(qCeil(m_progress));
++ }
++ }
++
++ void HelpGeneratorPrivate::cleanupDB()
++ {
++ if (m_query) {
++ m_query->clear();
++ delete m_query;
++ m_query = nullptr;
++ }
++ QSqlDatabase::removeDatabase(QLatin1String("builder"));
++ }
++
++ void HelpGeneratorPrivate::writeTree(QDataStream &s, QHelpDataContentItem *item, int depth)
++ {
++ s << depth;
++ s << item->reference();
++ s << item->title();
++ for (QHelpDataContentItem *i : item->children())
++ writeTree(s, i, depth + 1);
++ }
++
++ /*!
++ Returns the last error message.
++ */
++ QString HelpGeneratorPrivate::error() const
++ {
++ return m_error;
++ }
++
++ bool HelpGeneratorPrivate::createTables()
++ {
++ if (!m_query)
++ return false;
++
++ m_query->exec(QLatin1String("SELECT COUNT(*) FROM sqlite_master WHERE TYPE=\'table\'"
++ "AND Name=\'NamespaceTable\'"));
++ m_query->next();
++ if (m_query->value(0).toInt() > 0) {
++ m_error = tr("Some tables already exist.");
++ return false;
++ }
++
++ const QStringList tables = QStringList()
++ << QLatin1String("CREATE TABLE NamespaceTable ("
++ "Id INTEGER PRIMARY KEY,"
++ "Name TEXT )")
++ << QLatin1String("CREATE TABLE FilterAttributeTable ("
++ "Id INTEGER PRIMARY KEY, "
++ "Name TEXT )")
++ << QLatin1String("CREATE TABLE FilterNameTable ("
++ "Id INTEGER PRIMARY KEY, "
++ "Name TEXT )")
++ << QLatin1String("CREATE TABLE FilterTable ("
++ "NameId INTEGER, "
++ "FilterAttributeId INTEGER )")
++ << QLatin1String("CREATE TABLE IndexTable ("
++ "Id INTEGER PRIMARY KEY, "
++ "Name TEXT, "
++ "Identifier TEXT, "
++ "NamespaceId INTEGER, "
++ "FileId INTEGER, "
++ "Anchor TEXT )")
++ << QLatin1String("CREATE TABLE IndexFilterTable ("
++ "FilterAttributeId INTEGER, "
++ "IndexId INTEGER )")
++ << QLatin1String("CREATE TABLE ContentsTable ("
++ "Id INTEGER PRIMARY KEY, "
++ "NamespaceId INTEGER, "
++ "Data BLOB )")
++ << QLatin1String("CREATE TABLE ContentsFilterTable ("
++ "FilterAttributeId INTEGER, "
++ "ContentsId INTEGER )")
++ << QLatin1String("CREATE TABLE FileAttributeSetTable ("
++ "Id INTEGER, "
++ "FilterAttributeId INTEGER )")
++ << QLatin1String("CREATE TABLE FileDataTable ("
++ "Id INTEGER PRIMARY KEY, "
++ "Data BLOB )")
++ << QLatin1String("CREATE TABLE FileFilterTable ("
++ "FilterAttributeId INTEGER, "
++ "FileId INTEGER )")
++ << QLatin1String("CREATE TABLE FileNameTable ("
++ "FolderId INTEGER, "
++ "Name TEXT, "
++ "FileId INTEGER, "
++ "Title TEXT )")
++ << QLatin1String("CREATE TABLE FolderTable("
++ "Id INTEGER PRIMARY KEY, "
++ "Name Text, "
++ "NamespaceID INTEGER )")
++ << QLatin1String("CREATE TABLE MetaDataTable("
++ "Name Text, "
++ "Value BLOB )");
++
++ for (const QString &q : tables) {
++ if (!m_query->exec(q)) {
++ m_error = tr("Cannot create tables.");
++ return false;
++ }
++ }
++
++ m_query->exec(QLatin1String("INSERT INTO MetaDataTable VALUES('qchVersion', '1.0')"));
++
++ return true;
++ }
++
++ bool HelpGeneratorPrivate::insertFileNotFoundFile()
++ {
++ if (!m_query)
++ return false;
++
++ m_query->exec(QLatin1String("SELECT id FROM FileNameTable WHERE Name=\'\'"));
++ if (m_query->next() && m_query->isValid())
++ return true;
++
++ m_query->prepare(QLatin1String("INSERT INTO FileDataTable VALUES (Null, ?)"));
++ m_query->bindValue(0, QByteArray());
++ if (!m_query->exec())
++ return false;
++
++ const int fileId = m_query->lastInsertId().toInt();
++ m_query->prepare(QLatin1String("INSERT INTO FileNameTable (FolderId, Name, FileId, Title) "
++ " VALUES (0, '', ?, '')"));
++ m_query->bindValue(0, fileId);
++ if (fileId > -1 && m_query->exec()) {
++ m_fileMap.insert({}, fileId);
++ return true;
++ }
++ return false;
++ }
++
++ bool HelpGeneratorPrivate::registerVirtualFolder(const QString &folderName, const QString &ns)
++ {
++ if (!m_query || folderName.isEmpty() || ns.isEmpty())
++ return false;
++
++ m_query->prepare(QLatin1String("SELECT Id FROM FolderTable WHERE Name=?"));
++ m_query->bindValue(0, folderName);
++ m_query->exec();
++ m_query->next();
++ if (m_query->isValid() && m_query->value(0).toInt() > 0)
++ return true;
++
++ m_namespaceId = -1;
++ m_query->prepare(QLatin1String("SELECT Id FROM NamespaceTable WHERE Name=?"));
++ m_query->bindValue(0, ns);
++ m_query->exec();
++ while (m_query->next()) {
++ m_namespaceId = m_query->value(0).toInt();
++ break;
++ }
++
++ if (m_namespaceId < 0) {
++ m_query->prepare(QLatin1String("INSERT INTO NamespaceTable VALUES(NULL, ?)"));
++ m_query->bindValue(0, ns);
++ if (m_query->exec())
++ m_namespaceId = m_query->lastInsertId().toInt();
++ }
++
++ if (m_namespaceId > 0) {
++ m_query->prepare(QLatin1String("SELECT Id FROM FolderTable WHERE Name=?"));
++ m_query->bindValue(0, folderName);
++ m_query->exec();
++ while (m_query->next())
++ m_virtualFolderId = m_query->value(0).toInt();
++
++ if (m_virtualFolderId > 0)
++ return true;
++
++ m_query->prepare(QLatin1String("INSERT INTO FolderTable (NamespaceId, Name) "
++ "VALUES (?, ?)"));
++ m_query->bindValue(0, m_namespaceId);
++ m_query->bindValue(1, folderName);
++ if (m_query->exec()) {
++ m_virtualFolderId = m_query->lastInsertId().toInt();
++ return m_virtualFolderId > 0;
++ }
++ }
++ m_error = tr("Cannot register virtual folder.");
++ return false;
++ }
++
++ bool HelpGeneratorPrivate::insertFiles(const QStringList &files, const QString &rootPath,
++ const QStringList &filterAttributes)
++ {
++ if (!m_query)
++ return false;
++
++ emit statusChanged(tr("Insert files..."));
++ QSet<int> filterAtts;
++ for (const QString &filterAtt : filterAttributes) {
++ m_query->prepare(QLatin1String("SELECT Id FROM FilterAttributeTable "
++ "WHERE Name=?"));
++ m_query->bindValue(0, filterAtt);
++ m_query->exec();
++ if (m_query->next())
++ filterAtts.insert(m_query->value(0).toInt());
++ }
++
++ int filterSetId = -1;
++ m_query->exec(QLatin1String("SELECT MAX(Id) FROM FileAttributeSetTable"));
++ if (m_query->next())
++ filterSetId = m_query->value(0).toInt();
++ if (filterSetId < 0)
++ return false;
++ ++filterSetId;
++ QList<int> attValues = filterAtts.values();
++ std::sort(attValues.begin(), attValues.end());
++ for (int attId : std::as_const(attValues)) {
++ m_query->prepare(QLatin1String("INSERT INTO FileAttributeSetTable "
++ "VALUES(?, ?)"));
++ m_query->bindValue(0, filterSetId);
++ m_query->bindValue(1, attId);
++ m_query->exec();
++ }
++
++ int tableFileId = 1;
++ m_query->exec(QLatin1String("SELECT MAX(Id) FROM FileDataTable"));
++ if (m_query->next())
++ tableFileId = m_query->value(0).toInt() + 1;
++
++ QString title;
++ QString charSet;
++ QList<QByteArray> fileDataList;
++ QMap<int, QSet<int> > tmpFileFilterMap;
++ QList<FileNameTableData> fileNameDataList;
++
++ int i = 0;
++ for (const QString &file : files) {
++ const QString fileName = QDir::cleanPath(file);
++
++ QFile fi(rootPath + QDir::separator() + fileName);
++ if (!fi.exists()) {
++ emit warning(tr("The file %1 does not exist, skipping it...")
++ .arg(QDir::cleanPath(rootPath + QDir::separator() + fileName)));
++ continue;
++ }
++
++ if (!fi.open(QIODevice::ReadOnly)) {
++ emit warning(tr("Cannot open file %1, skipping it...")
++ .arg(QDir::cleanPath(rootPath + QDir::separator() + fileName)));
++ continue;
++ }
++
++ QByteArray data = fi.readAll();
++ if (fileName.endsWith(QLatin1String(".html"))
++ || fileName.endsWith(QLatin1String(".htm"))) {
++ auto encoding = QStringDecoder::encodingForHtml(data);
++ if (!encoding)
++ encoding = QStringDecoder::Utf8;
++ title = QHelpGlobal::documentTitle(QStringDecoder(*encoding)(data));
++ } else {
++ title = fileName.mid(fileName.lastIndexOf(QLatin1Char('/')) + 1);
++ }
++
++ int fileId = -1;
++ const auto &it = m_fileMap.constFind(fileName);
++ if (it == m_fileMap.cend()) {
++ fileDataList.append(qCompress(data));
++
++ FileNameTableData fileNameData;
++ fileNameData.name = fileName;
++ fileNameData.fileId = tableFileId;
++ fileNameData.title = title;
++ fileNameDataList.append(fileNameData);
++
++ m_fileMap.insert(fileName, tableFileId);
++ m_fileFilterMap.insert(tableFileId, filterAtts);
++ tmpFileFilterMap.insert(tableFileId, filterAtts);
++
++ ++tableFileId;
++ } else {
++ fileId = it.value();
++ QSet<int> &fileFilterSet = m_fileFilterMap[fileId];
++ QSet<int> &tmpFileFilterSet = tmpFileFilterMap[fileId];
++ for (int filter : std::as_const(filterAtts)) {
++ if (!fileFilterSet.contains(filter)
++ && !tmpFileFilterSet.contains(filter)) {
++ fileFilterSet.insert(filter);
++ tmpFileFilterSet.insert(filter);
++ }
++ }
++ }
++ }
++
++ if (!tmpFileFilterMap.isEmpty()) {
++ m_query->exec(QLatin1String("BEGIN"));
++ for (auto it = tmpFileFilterMap.cbegin(), end = tmpFileFilterMap.cend(); it != end; ++it) {
++ QList<int> filterValues = it.value().values();
++ std::sort(filterValues.begin(), filterValues.end());
++ for (int fv : std::as_const(filterValues)) {
++ m_query->prepare(QLatin1String("INSERT INTO FileFilterTable "
++ "VALUES(?, ?)"));
++ m_query->bindValue(0, fv);
++ m_query->bindValue(1, it.key());
++ m_query->exec();
++ }
++ }
++
++ for (const QByteArray &fileData : std::as_const(fileDataList)) {
++ m_query->prepare(QLatin1String("INSERT INTO FileDataTable VALUES "
++ "(Null, ?)"));
++ m_query->bindValue(0, fileData);
++ m_query->exec();
++ if (++i % 20 == 0)
++ addProgress(m_fileStep * 20.0);
++ }
++
++ for (const FileNameTableData &fnd : std::as_const(fileNameDataList)) {
++ m_query->prepare(QLatin1String("INSERT INTO FileNameTable "
++ "(FolderId, Name, FileId, Title) VALUES (?, ?, ?, ?)"));
++ m_query->bindValue(0, 1);
++ m_query->bindValue(1, fnd.name);
++ m_query->bindValue(2, fnd.fileId);
++ m_query->bindValue(3, fnd.title);
++ m_query->exec();
++ }
++ m_query->exec(QLatin1String("COMMIT"));
++ }
++
++ m_query->exec(QLatin1String("SELECT MAX(Id) FROM FileDataTable"));
++ if (m_query->next()
++ && m_query->value(0).toInt() == tableFileId - 1) {
++ addProgress(m_fileStep*(i % 20));
++ return true;
++ }
++ return false;
++ }
++
++ bool HelpGeneratorPrivate::registerCustomFilter(const QString &filterName,
++ const QStringList &filterAttribs, bool forceUpdate)
++ {
++ if (!m_query)
++ return false;
++
++ m_query->exec(QLatin1String("SELECT Id, Name FROM FilterAttributeTable"));
++ QStringList idsToInsert = filterAttribs;
++ QMap<QString, int> attributeMap;
++ while (m_query->next()) {
++ attributeMap.insert(m_query->value(1).toString(),
++ m_query->value(0).toInt());
++ idsToInsert.removeAll(m_query->value(1).toString());
++ }
++
++ for (const QString &id : std::as_const(idsToInsert)) {
++ m_query->prepare(QLatin1String("INSERT INTO FilterAttributeTable VALUES(NULL, ?)"));
++ m_query->bindValue(0, id);
++ m_query->exec();
++ attributeMap.insert(id, m_query->lastInsertId().toInt());
++ }
++
++ int nameId = -1;
++ m_query->prepare(QLatin1String("SELECT Id FROM FilterNameTable WHERE Name=?"));
++ m_query->bindValue(0, filterName);
++ m_query->exec();
++ while (m_query->next()) {
++ nameId = m_query->value(0).toInt();
++ break;
++ }
++
++ if (nameId < 0) {
++ m_query->prepare(QLatin1String("INSERT INTO FilterNameTable VALUES(NULL, ?)"));
++ m_query->bindValue(0, filterName);
++ if (m_query->exec())
++ nameId = m_query->lastInsertId().toInt();
++ } else if (!forceUpdate) {
++ m_error = tr("The filter %1 is already registered.").arg(filterName);
++ return false;
++ }
++
++ if (nameId < 0) {
++ m_error = tr("Cannot register filter %1.").arg(filterName);
++ return false;
++ }
++
++ m_query->prepare(QLatin1String("DELETE FROM FilterTable WHERE NameId=?"));
++ m_query->bindValue(0, nameId);
++ m_query->exec();
++
++ for (const QString &att : filterAttribs) {
++ m_query->prepare(QLatin1String("INSERT INTO FilterTable VALUES(?, ?)"));
++ m_query->bindValue(0, nameId);
++ m_query->bindValue(1, attributeMap[att]);
++ if (!m_query->exec())
++ return false;
++ }
++ return true;
++ }
++
++ bool HelpGeneratorPrivate::insertKeywords(const QList<QHelpDataIndexItem> &keywords,
++ const QStringList &filterAttributes)
++ {
++ if (!m_query)
++ return false;
++
++ emit statusChanged(tr("Insert indices..."));
++ int indexId = 1;
++ m_query->exec(QLatin1String("SELECT MAX(Id) FROM IndexTable"));
++ if (m_query->next())
++ indexId = m_query->value(0).toInt() + 1;
++
++ QList<int> filterAtts;
++ for (const QString &filterAtt : filterAttributes) {
++ m_query->prepare(QLatin1String("SELECT Id FROM FilterAttributeTable WHERE Name=?"));
++ m_query->bindValue(0, filterAtt);
++ m_query->exec();
++ if (m_query->next())
++ filterAtts.append(m_query->value(0).toInt());
++ }
++
++ QList<int> indexFilterTable;
++
++ int i = 0;
++ m_query->exec(QLatin1String("BEGIN"));
++ QSet<QString> indices;
++ for (const QHelpDataIndexItem &itm : keywords) {
++ // Identical ids make no sense and just confuse the Assistant user,
++ // so we ignore all repetitions.
++ if (indices.contains(itm.identifier))
++ continue;
++
++ // Still empty ids should be ignored, as otherwise we will include only
++ // the first keyword with an empty id.
++ if (!itm.identifier.isEmpty())
++ indices.insert(itm.identifier);
++
++ const int pos = itm.reference.indexOf(QLatin1Char('#'));
++ const QString &fileName = itm.reference.left(pos);
++ const QString anchor = pos < 0 ? QString() : itm.reference.mid(pos + 1);
++
++ const QString &fName = QDir::cleanPath(fileName);
++
++ const auto &it = m_fileMap.constFind(fName);
++ const int fileId = it == m_fileMap.cend() ? 1 : it.value();
++
++ m_query->prepare(QLatin1String("INSERT INTO IndexTable (Name, Identifier, NamespaceId, FileId, Anchor) "
++ "VALUES(?, ?, ?, ?, ?)"));
++ m_query->bindValue(0, itm.name);
++ m_query->bindValue(1, itm.identifier);
++ m_query->bindValue(2, m_namespaceId);
++ m_query->bindValue(3, fileId);
++ m_query->bindValue(4, anchor);
++ m_query->exec();
++
++ indexFilterTable.append(indexId++);
++ if (++i % 100 == 0)
++ addProgress(m_indexStep * 100.0);
++ }
++ m_query->exec(QLatin1String("COMMIT"));
++
++ m_query->exec(QLatin1String("BEGIN"));
++ for (int idx : std::as_const(indexFilterTable)) {
++ for (int a : std::as_const(filterAtts)) {
++ m_query->prepare(QLatin1String("INSERT INTO IndexFilterTable (FilterAttributeId, IndexId) "
++ "VALUES(?, ?)"));
++ m_query->bindValue(0, a);
++ m_query->bindValue(1, idx);
++ m_query->exec();
++ }
++ }
++ m_query->exec(QLatin1String("COMMIT"));
++
++ m_query->exec(QLatin1String("SELECT COUNT(Id) FROM IndexTable"));
++ if (m_query->next() && m_query->value(0).toInt() >= indices.size())
++ return true;
++ return false;
++ }
++
++ bool HelpGeneratorPrivate::insertContents(const QByteArray &ba,
++ const QStringList &filterAttributes)
++ {
++ if (!m_query)
++ return false;
++
++ emit statusChanged(tr("Insert contents..."));
++ m_query->prepare(QLatin1String("INSERT INTO ContentsTable (NamespaceId, Data) "
++ "VALUES(?, ?)"));
++ m_query->bindValue(0, m_namespaceId);
++ m_query->bindValue(1, ba);
++ m_query->exec();
++ int contentId = m_query->lastInsertId().toInt();
++ if (contentId < 1) {
++ m_error = tr("Cannot insert contents.");
++ return false;
++ }
++
++ // associate the filter attributes
++ for (const QString &filterAtt : filterAttributes) {
++ m_query->prepare(QLatin1String("INSERT INTO ContentsFilterTable (FilterAttributeId, ContentsId) "
++ "SELECT Id, ? FROM FilterAttributeTable WHERE Name=?"));
++ m_query->bindValue(0, contentId);
++ m_query->bindValue(1, filterAtt);
++ m_query->exec();
++ if (!m_query->isActive()) {
++ m_error = tr("Cannot register contents.");
++ return false;
++ }
++ }
++ addProgress(m_contentStep);
++ return true;
++ }
++
++ bool HelpGeneratorPrivate::insertFilterAttributes(const QStringList &attributes)
++ {
++ if (!m_query)
++ return false;
++
++ m_query->exec(QLatin1String("SELECT Name FROM FilterAttributeTable"));
++ QSet<QString> atts;
++ while (m_query->next())
++ atts.insert(m_query->value(0).toString());
++
++ for (const QString &s : attributes) {
++ if (!atts.contains(s)) {
++ m_query->prepare(QLatin1String("INSERT INTO FilterAttributeTable VALUES(NULL, ?)"));
++ m_query->bindValue(0, s);
++ m_query->exec();
++ }
++ }
++ return true;
++ }
++
++ bool HelpGeneratorPrivate::insertMetaData(const QMap<QString, QVariant> &metaData)
++ {
++ if (!m_query)
++ return false;
++
++ for (auto it = metaData.cbegin(), end = metaData.cend(); it != end; ++it) {
++ m_query->prepare(QLatin1String("INSERT INTO MetaDataTable VALUES(?, ?)"));
++ m_query->bindValue(0, it.key());
++ m_query->bindValue(1, it.value());
++ m_query->exec();
++ }
++ return true;
++ }
++
++ bool HelpGeneratorPrivate::checkLinks(const QHelpProjectData &helpData)
++ {
++ /*
++ * Step 1: Gather the canoncal file paths of all files in the project.
++ * We use a set, because there will be a lot of look-ups.
++ */
++ QSet<QString> files;
++ for (const QHelpDataFilterSection &filterSection : helpData.filterSections()) {
++ for (const QString &file : filterSection.files()) {
++ const QFileInfo fileInfo(helpData.rootPath() + QDir::separator() + file);
++ const QString &canonicalFileName = fileInfo.canonicalFilePath();
++ if (!fileInfo.exists())
++ emit warning(tr("File \"%1\" does not exist.").arg(file));
++ else
++ files.insert(canonicalFileName);
++ }
++ }
++
++ /*
++ * Step 2: Check the hypertext and image references of all HTML files.
++ * Note that we don't parse the files, but simply grep for the
++ * respective HTML elements. Therefore. contents that are e.g.
++ * commented out can cause false warning.
++ */
++ bool allLinksOk = true;
++ for (const QString &fileName : std::as_const(files)) {
++ if (!fileName.endsWith(QLatin1String("html"))
++ && !fileName.endsWith(QLatin1String("htm")))
++ continue;
++ QFile htmlFile(fileName);
++ if (!htmlFile.open(QIODevice::ReadOnly)) {
++ emit warning(tr("File \"%1\" cannot be opened.").arg(fileName));
++ continue;
++ }
++ const QRegularExpression linkPattern(QLatin1String("<(?:a href|img src)=\"?([^#\">]+)[#\">]"));
++ QByteArray data = htmlFile.readAll();
++ auto encoding = QStringDecoder::encodingForHtml(data);
++ if (!encoding)
++ encoding = QStringDecoder::Utf8;
++ const QString &content = QStringDecoder(*encoding)(data);
++ QStringList invalidLinks;
++ QRegularExpressionMatch match;
++ int pos = 0;
++ while ((match = linkPattern.match(content, pos)).hasMatch()) {
++ pos = match.capturedEnd();
++ const QString &linkedFileName = match.captured(1);
++ if (linkedFileName.contains(QLatin1String("://")))
++ continue;
++ const QString &curDir = QFileInfo(fileName).dir().path();
++ const QString &canonicalLinkedFileName =
++ QFileInfo(curDir + QDir::separator() + linkedFileName).canonicalFilePath();
++ if (!files.contains(canonicalLinkedFileName)
++ && !invalidLinks.contains(canonicalLinkedFileName)) {
++ emit warning(tr("File \"%1\" contains an invalid link to file \"%2\"").
++ arg(fileName).arg(linkedFileName));
++ allLinksOk = false;
++ invalidLinks.append(canonicalLinkedFileName);
++ }
++ }
++ }
++
++ if (!allLinksOk)
++ m_error = tr("Invalid links in HTML files.");
++ return allLinksOk;
++ }
++
++ //////////////////////////////
++
++ HelpGenerator::HelpGenerator(bool silent)
++ {
++ m_private = new HelpGeneratorPrivate(this);
++ if (!silent) {
++ connect(m_private, &HelpGeneratorPrivate::statusChanged,
++ this, &HelpGenerator::printStatus);
++ }
++ connect(m_private, &HelpGeneratorPrivate::warning,
++ this, &HelpGenerator::printWarning);
++ }
++
++ bool HelpGenerator::generate(QHelpProjectData *helpData,
++ const QString &outputFileName)
++ {
++ return m_private->generate(helpData, outputFileName);
++ }
++
++ bool HelpGenerator::checkLinks(const QHelpProjectData &helpData)
++ {
++ return m_private->checkLinks(helpData);
++ }
++
++ QString HelpGenerator::error() const
++ {
++ return m_private->error();
++ }
++
++ void HelpGenerator::printStatus(const QString &msg)
++ {
++ puts(qPrintable(msg));
++ }
++
++ void HelpGenerator::printWarning(const QString &msg)
++ {
++ puts(qPrintable(tr("Warning: %1").arg(msg)));
++ }
++
++ QT_END_NAMESPACE
++
++ #include "helpgenerator.moc"