Allow considering the regular package when checking for updates

libpkg/data/database.cpp

@@ -306,14 +306,20 @@ std::unordered_map<std::shared_ptr<Package>, UnresolvedDependencies> Database::d
     return unresolvedPackages;
 }
 
-LibPkg::PackageUpdates LibPkg::Database::checkForUpdates(const std::vector<LibPkg::Database *> &updateSources)
+LibPkg::PackageUpdates LibPkg::Database::checkForUpdates(const std::vector<LibPkg::Database *> &updateSources, UpdateCheckOptions options)
 {
     PackageUpdates results;
-    for (const auto &myPackageIterator : packages) {
+    for (const auto &[myPackageName, myPackage] : packages) {
-        const auto &myPackage = myPackageIterator.second;
+        auto regularName = std::string();
+        if (options & UpdateCheckOptions::ConsiderRegularPackage) {
+            const auto decomposedName = myPackage->decomposeName();
+            if ((!decomposedName.targetPrefix.empty() || !decomposedName.vcsSuffix.empty()) && !decomposedName.isVcsPackage()) {
+                regularName = decomposedName.actualName;
+            }
+        }
         auto foundPackage = false;
-        for (auto *updateSource : updateSources) {
+        for (auto *const updateSource : updateSources) {
-            const auto updatePackageIterator = updateSource->packages.find(myPackageIterator.first);
+            const auto updatePackageIterator = updateSource->packages.find(myPackageName);
             if (updatePackageIterator == updateSource->packages.cend()) {
                 continue;
             }
@@ -340,6 +346,33 @@ LibPkg::PackageUpdates LibPkg::Database::checkForUpdates(const std::vector<LibPk
         if (!foundPackage) {
             results.orphans.emplace_back(PackageSearchResult(*this, myPackage));
         }
+        if (regularName.empty()) {
+            continue;
+        }
+        for (auto *const updateSource : updateSources) {
+            const auto updatePackageIterator = updateSource->packages.find(regularName);
+            if (updatePackageIterator == updateSource->packages.cend()) {
+                continue;
+            }
+            const auto &updatePackage = updatePackageIterator->second;
+            const auto versionDiff = myPackage->compareVersion(*updatePackage);
+            std::vector<PackageUpdate> *list = nullptr;
+            switch (versionDiff) {
+            case PackageVersionComparison::SoftwareUpgrade:
+                list = &results.versionUpdates;
+                break;
+            case PackageVersionComparison::PackageUpgradeOnly:
+                list = &results.packageUpdates;
+                break;
+            case PackageVersionComparison::NewerThanSyncVersion:
+                list = &results.downgrades;
+                break;
+            default:;
+            }
+            if (list) {
+                list->emplace_back(PackageSearchResult(*this, myPackage), PackageSearchResult(*updateSource, updatePackage));
+            }
+        }
     }
     return results;
 }

libpkg/data/database.h

@@ -42,16 +42,22 @@ struct LIBPKG_EXPORT PackageSearchResult {
  */
 enum class DatabaseUsage {
     None = 0,
-    Sync = 1, /*! The database is used when synchronizing. */
+    Sync = (1 << 0), /*! The database is used when synchronizing. */
     Search = (1 << 1), /*! The database is used when searching. */
     Install = (1 << 2), /*! The database is used to install packages. */
     Upgrade = (1 << 3), /*! The database is used to upgrade packages. */
     All = (1 << 4) - 1, /*! The database is used for everything. */
 };
 
+enum class UpdateCheckOptions {
+    None = 0,
+    ConsiderRegularPackage = (1 << 0),
+};
+
 } // namespace LibPkg
 
 CPP_UTILITIES_MARK_FLAG_ENUM_CLASS(LibPkg, LibPkg::DatabaseUsage)
+CPP_UTILITIES_MARK_FLAG_ENUM_CLASS(LibPkg, LibPkg::UpdateCheckOptions)
 
 namespace LibPkg {
 
@@ -109,7 +115,7 @@ struct LIBPKG_EXPORT Database : public ReflectiveRapidJSON::JsonSerializable<Dat
     void replacePackages(const std::vector<std::shared_ptr<Package>> &newPackages, CppUtilities::DateTime lastModified);
     std::unordered_map<std::shared_ptr<Package>, UnresolvedDependencies> detectUnresolvedPackages(
         Config &config, const std::vector<std::shared_ptr<Package>> &newPackages, const DependencySet &removedPackages);
-    PackageUpdates checkForUpdates(const std::vector<Database *> &updateSources);
+    PackageUpdates checkForUpdates(const std::vector<Database *> &updateSources, UpdateCheckOptions options = UpdateCheckOptions::None);
     PackageLocation locatePackage(const std::string &packageName) const;
     std::string filesPathFromRegularPath() const;
 

librepomgr/buildactions/buildactionmeta.cpp

@@ -59,7 +59,14 @@ BuildActionMetaInfo::BuildActionMetaInfo()
             .category = "Repo management",
             .name = "Check for updates",
             .type = "check-updates",
-            .flags = {},
+            .flags = {
+                BuildActionFlagMetaInfo{
+                    .id = static_cast<BuildActionFlagType>(CheckForUpdatesFlags::ConsiderRegularPackage),
+                    .name = "Consider regular package",
+                    .desc = "When processing a variant package like mingw-w64-qt6-base compare with the regular qt6-base package as well",
+                    .param = "consider-regular-package",
+                },
+            },
             .settings = {},
             .directory = false,
             .sourceDb = true,

librepomgr/buildactions/buildactionmeta.h

@@ -51,6 +51,10 @@ enum class BuildActionType : std::uint64_t {
 
 using BuildActionFlagType = std::uint64_t;
 static constexpr BuildActionFlagType noBuildActionFlags = 0;
+enum class CheckForUpdatesFlags : BuildActionFlagType {
+    None,
+    ConsiderRegularPackage = (1 << 0), // be consistent with LibPkg::UpdateCheckOptions here
+};
 enum class ReloadLibraryDependenciesFlags : BuildActionFlagType {
     None,
     ForceReload = (1 << 0),

librepomgr/buildactions/buildactionprivate.h

@@ -371,6 +371,7 @@ struct LIBREPOMGR_EXPORT UpdateCheck : public InternalBuildAction {
 private:
     LibPkg::PackageUpdates checkForUpdates();
 
+    LibPkg::UpdateCheckOptions m_options = LibPkg::UpdateCheckOptions::None;
     bool m_packageLookupDone = false;
 };
 

librepomgr/buildactions/updatecheck.cpp

@@ -16,6 +16,9 @@ UpdateCheck::UpdateCheck(ServiceSetup &setup, const std::shared_ptr<BuildAction>
 
 void UpdateCheck::run()
 {
+    const auto flags = static_cast<CheckForUpdatesFlags>(m_buildAction->flags);
+    m_options = static_cast<LibPkg::UpdateCheckOptions>(flags);
+
     auto configReadLock = init(BuildActionAccess::ReadConfig,
         RequiredDatabases::OneOrMoreSources | RequiredDatabases::OneDestination | RequiredDatabases::AllowFromAur, RequiredParameters::None);
     if (holds_alternative<monostate>(configReadLock)) {
@@ -47,7 +50,7 @@ LibPkg::PackageUpdates UpdateCheck::checkForUpdates()
     if (m_fromAur) {
         sourceDbs.emplace_back(&m_setup.config.aur);
     }
-    return (**m_destinationDbs.begin()).checkForUpdates(sourceDbs);
+    return (**m_destinationDbs.begin()).checkForUpdates(sourceDbs, m_options);
 }
 
 } // namespace LibRepoMgr

srv/static/js/buildactionspage.js

@@ -722,7 +722,7 @@ function isBuildActionSourceAur(buildActionInfo)
     return Array.isArray(sourceDbs) && sourceDbs.length === 1 && sourceDbs[0] == 'aur';
 }
 
-function renderUpdateInfoWithCheckbox(id, packageName, versionInfo, sourceFromAur)
+function renderUpdateInfoWithCheckbox(id, packageName, newPackageName, versionInfo, sourceFromAur)
 {
     const inputElement = document.createElement('input');
     inputElement.type = 'checkbox';
@@ -730,13 +730,21 @@ function renderUpdateInfoWithCheckbox(id, packageName, versionInfo, sourceFromAu
     inputElement.value = packageName;
     const labelElement = document.createElement('label');
     labelElement.htmlFor = id;
-    if (sourceFromAur) {
+    if (sourceFromAur && newPackageName) {
         const packageNameLink = document.createElement('a');
-        packageNameLink.href = 'https://aur.archlinux.org/packages/' + packageName;
+        packageNameLink.href = 'https://aur.archlinux.org/packages/' + newPackageName;
         packageNameLink.target = '_blank';
-        packageNameLink.appendChild(document.createTextNode(packageName));
+        packageNameLink.appendChild(document.createTextNode(newPackageName));
+        if (newPackageName !== packageName) {
+            labelElement.appendChild(document.createTextNode(packageName + ' ('));
+        }
         labelElement.appendChild(packageNameLink);
+        if (newPackageName !== packageName) {
+            labelElement.appendChild(document.createTextNode(')'));
+        }
         labelElement.appendChild(document.createTextNode(': ' + versionInfo));
+    } else if (newPackageName && packageName !== newPackageName) {
+        labelElement.appendChild(document.createTextNode(packageName + ' (' + newPackageName + '): ' + versionInfo));
     } else {
         labelElement.appendChild(document.createTextNode(packageName + ': ' + versionInfo));
     }
@@ -807,6 +815,7 @@ function renderOrphanPackage(value, obj, level, row)
         return renderUpdateInfoWithCheckbox(
             'update-info-checkbox-' + packageName + '-' + package.version,
             packageName,
+            undefined,
             package.version
         );
         return document.createTextNode();
@@ -825,6 +834,7 @@ function renderUpdateOrDowngrade(value, obj, level, row)
         return renderUpdateInfoWithCheckbox(
             'update-info-checkbox-' + packageName + '-' + oldVersion.version + '-' + newVersion.version,
             packageName,
+            newVersion.name,
             oldVersion.version + ' → ' + newVersion.version,
             sourceFromAur
         );