Implement system_package_manager::downstream_package_version()

1 files changed, 288 insertions, 58 deletions

diff --git a/bpkg/system-package-manager.cxx b/bpkg/system-package-manager.cxx
index 78c5ce3..5e933ae 100644
--- a/bpkg/system-package-manager.cxx
+++ b/bpkg/system-package-manager.cxx
@@ -3,6 +3,9 @@
 
 #include <bpkg/system-package-manager.hxx>
 
+#include <sstream>
+
+#include <libbutl/regex.hxx>
 #include <libbutl/semantic-version.hxx>
 
 #include <bpkg/package.hxx>
@@ -77,29 +80,97 @@ namespace bpkg
     return r;
   }
 
-  strings system_package_manager::
-  system_package_names (const available_packages& aps,
-                        const string& name_id,
-                        const string& version_id,
-                        const vector<string>& like_ids)
+  // Return the version id parsed as a semantic version if it is not empty and
+  // the "0" semantic version otherwise. Issue diagnostics and fail on the
+  // parsing error.
+  //
+  // Note: the name_id argument is only used for diagnostics.
+  //
+  static inline semantic_version
+  parse_version_id (const string& version_id, const string& name_id)
   {
-    assert (!aps.empty ());
+    if (version_id.empty ())
+      return semantic_version (0, 0, 0);
+
+    try
+    {
+      return semantic_version (version_id, semantic_version::allow_omit_minor);
+    }
+    catch (const invalid_argument& e)
+    {
+      fail << "invalid version '" << version_id << "' for " << name_id
+           << " operating system: " << e << endf;
+    }
+  }
+
+  // Parse the <distribution> component of the specified <distribution>-*
+  // value into the distribution name and version (returne as "0" if not
+  // present). Issue diagnostics and fail on the parsing error.
+  //
+  // Note: the value_name, ap, and af arguments are only used for diagnostics.
+  //
+  static pair<string, semantic_version>
+  parse_distribution (string&& d,
+                      const string& value_name,
+                      const shared_ptr<available_package>& ap,
+                      const lazy_shared_ptr<repository_fragment>& af)
+  {
+    string dn (move (d));      // <name>[_<version>]
+    size_t p (dn.rfind ('_')); // Version-separating underscore.
 
-    // Parse the version id if it is not empty and leave it "0" otherwise.
+    // If '_' separator is present, then make sure that the right-hand part
+    // looks like a version (is not empty and only contains digits and dots).
     //
-    semantic_version vid;
+    if (p != string::npos)
+    {
+      if (p != dn.size () - 1)
+      {
+        for (size_t i (p + 1); i != dn.size (); ++i)
+        {
+          if (!digit (dn[i]) && dn[i] != '.')
+          {
+            p = string::npos;
+            break;
+          }
+        }
+      }
+      else
+        p = string::npos;
+    }
 
-    if (!version_id.empty ())
+    // Parse the distribution version if present and leave it "0" otherwise.
+    //
+    semantic_version dv (0, 0, 0);
+    if (p != string::npos)
     try
     {
-      vid = semantic_version (version_id, semantic_version::allow_omit_minor);
+      dv = semantic_version (dn,
+                             p + 1,
+                             semantic_version::allow_omit_minor);
+
+      dn.resize (p);
     }
     catch (const invalid_argument& e)
     {
-      fail << "invalid version '" << version_id << "' for " << name_id
-           << " operating system: " << e;
+      fail << "invalid distribution version '" << string (dn, p + 1)
+           << "' in value " << value_name << " for package " << ap->id.name
+           << ' ' << ap->version << af.database () << " in repository "
+           << af.load ()->location << ": " << e;
     }
 
+    return make_pair (move (dn), move (dv));
+  }
+
+  strings system_package_manager::
+  system_package_names (const available_packages& aps,
+                        const string& name_id,
+                        const string& version_id,
+                        const vector<string>& like_ids)
+  {
+    assert (!aps.empty ());
+
+    semantic_version vid (parse_version_id (version_id, name_id));
+
     // Return those <name>[_<version>]-name distribution values of the
     // specified available packages whose <name> component matches the
     // specified distribution name and the <version> component (assumed as "0"
@@ -120,53 +191,11 @@ namespace bpkg
         {
           if (optional<string> d = nv.distribution ("-name"))
           {
-            string dn (move (*d));     // <name>[_<version>]
-            size_t p (dn.rfind ('_')); // Version-separating underscore.
+            pair<string, semantic_version> dnv (
+              parse_distribution (move (*d), nv.name, ap, a.second));
 
-            // If '_' separator is present, then make sure that the right-hand
-            // part looks like a version (not empty and only contains digits
-            // and dots).
-            //
-            if (p != string::npos)
-            {
-              if (p != dn.size () - 1)
-              {
-                for (size_t i (p); i != dn.size (); ++i)
-                {
-                  if (!digit (dn[i]) && dn[i] != '.')
-                  {
-                    p = string::npos;
-                    break;
-                  }
-                }
-              }
-              else
-                p = string::npos;
-            }
-
-            // Parse the distribution version if present and leave it "0"
-            // otherwise.
-            //
-            semantic_version dv;
-            if (p != string::npos)
-            try
-            {
-              dv = semantic_version (dn,
-                                     p + 1,
-                                     semantic_version::allow_omit_minor);
-            }
-            catch (const invalid_argument& e)
-            {
-              fail << "invalid distribution version in value " << nv.name
-                   << " for package " << ap->id.name << ' ' << ap->version
-                   << a.second.database () << " in repository "
-                   << a.second.load ()->location << ": " << e;
-            }
-
-            dn.resize (p);
-
-            if (dn == n &&
-                dv <= v &&
+            if (dnv.first  == n &&
+                dnv.second <= v &&
                 find_if (r.begin (), r.end (),
                          [&nv] (const distribution_name_value& v)
                          {return v.name == nv.name || v.value == nv.value;}) ==
@@ -213,4 +242,205 @@ namespace bpkg
 
     return r;
   }
+
+  optional<version> system_package_manager::
+  downstream_package_version (const string& system_version,
+                              const available_packages& aps,
+                              const string& name_id,
+                              const string& version_id,
+                              const vector<string>& like_ids)
+  {
+    semantic_version vid (parse_version_id (version_id, name_id));
+
+    // Iterate over the passed available packages (in version descending
+    // order) and over the <name>[_<version>]-to-downstream-version
+    // distribution values they contain. Only consider those values whose
+    // <name> component matches the specified distribution name and the
+    // <version> component (assumed as "0" if not present) is less or equal
+    // the specified distribution version. For such values match the regex
+    // pattern against the passed system version and if it matches consider
+    // the replacement as the resulting downstream version candidate. Return
+    // this downstream version if the distribution version is equal to the
+    // specified one. Otherwise (the version is less), continue iterating
+    // while preferring downstream version candidates for greater distribution
+    // versions. Note that here we are trying to use a version mapping for the
+    // distribution version most close (but never greater) to the specified
+    // distribution version. So, for example, if both following values contain
+    // a matching mapping, then for debian 11 we prefer the downstream version
+    // produced by the debian_10-to-downstream-version value:
+    //
+    // debian_9-to-downstream-version
+    // debian_10-to-downstream-version
+    //
+    auto downstream_version = [&aps, &system_version]
+                              (const string& n, const semantic_version& v)
+      -> optional<version>
+    {
+      optional<version> r;
+      semantic_version rv;
+
+      for (const auto& a: aps)
+      {
+        const shared_ptr<available_package>& ap (a.first);
+
+        for (const distribution_name_value& nv: ap->distribution_values)
+        {
+          if (optional<string> d = nv.distribution ("-to-downstream-version"))
+          {
+            pair<string, semantic_version> dnv (
+              parse_distribution (move (*d), nv.name, ap, a.second));
+
+            if (dnv.first == n && dnv.second <= v)
+            {
+              auto bad_value = [&nv, &ap, &a] (const string& d)
+              {
+                const lazy_shared_ptr<repository_fragment>& af (a.second);
+
+                fail << "invalid distribution value '" << nv.name << ": "
+                     << nv.value << "' for package " << ap->id.name << ' '
+                     << ap->version << af.database () << " in repository "
+                     << af.load ()->location << ": " << d;
+              };
+
+              // Parse the distribution value into the regex pattern and the
+              // replacement.
+              //
+              const string& val (nv.value);
+
+              if (val[0] != '/')
+                bad_value ("first character must be '/'");
+
+              if (val.size () < 2 || val.back () != '/')
+                bad_value ("last character must be '/'");
+
+              // Find '/' which separates the pattern and replacement
+              // components. For good measure, search backwards from position
+              // which preceeds the trailing '/'.
+              //
+              size_t p (val.rfind ('/', val.size () - 2));
+              assert (p != string::npos); // There is always the leading '/'.
+
+              if (p == 0)
+                bad_value ("no replacement component");
+
+              string pat (val, 1, p - 1);
+              string rep (val, p + 1, val.size () - p - 2);
+
+              // Match the regex and skip it if it doesn't match or proceed to
+              // parsing the downstream version resulting from the regex
+              // replacement otherwise.
+              //
+              string dv;
+              try
+              {
+                regex re (pat, regex::ECMAScript);
+
+                pair<string, bool> rr (
+                  regex_replace_match (system_version, re, rep));
+
+                // Skip the regex if it doesn't match.
+                //
+                if (!rr.second)
+                  continue;
+
+                dv = move (rr.first);
+              }
+              catch (const regex_error& e)
+              {
+                // Print regex_error description if meaningful (no space).
+                //
+                ostringstream os;
+                os << "invalid regex pattern '" << pat << "'" << e;
+                bad_value (os.str ());
+              }
+
+              // Parse the downstream version.
+              //
+              try
+              {
+                version ver (dv);
+
+                // If the distribution version is equal to the specified one,
+                // then we are done. Otherwise, save the version if it is
+                // preferable and continue iterating.
+                //
+                // Note that bailing out immediately in the former case is
+                // essential. Otherwise, we can potentially fail later on, for
+                // example, some ill-formed regex which is already fixed in
+                // some newer package.
+                //
+                if (dnv.second == v)
+                  return ver;
+
+                if (!r || rv < dnv.second)
+                {
+                  r = move (ver);
+                  rv = move (dnv.second);
+                }
+              }
+              catch (const invalid_argument& e)
+              {
+                bad_value ("resulting downstream version '" + dv +
+                           "' is invalid: " + e.what ());
+              }
+            }
+          }
+          //
+          // Try to also deduce the downstream version using the *-version
+          // distribution value.
+          //
+          else if (!ap->stub ())
+          {
+            // Note that the below logic is a simplified version of the above
+            // *-to-downstream-version value handling.
+            //
+            if (optional<string> d = nv.distribution ("-version"))
+            {
+              pair<string, semantic_version> dnv (
+                parse_distribution (move (*d), nv.name, ap, a.second));
+
+              if (dnv.first == n && dnv.second <= v)
+              {
+                if (nv.value == system_version)
+                {
+                  if (dnv.second == v)
+                    return ap->version;
+
+                  if (!r || rv < dnv.second)
+                  {
+                    r = ap->version;
+                    rv = move (dnv.second);
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+
+      return r;
+    };
+
+    // Try to deduce the downstream version using the
+    // <distribution>-to-downstream-version values that match the name id and
+    // refer to the version which is less or equal than the version id.
+    //
+    optional<version> r (downstream_version (name_id, vid));
+
+    // If the downstream version is not deduced and the like ids are
+    // specified, then re-try but now using the like id and "0" version id
+    // instead.
+    //
+    if (!r)
+    {
+      for (const string& like_id: like_ids)
+      {
+        r = downstream_version (like_id, semantic_version (0, 0, 0));
+        if (r)
+          break;
+      }
+    }
+
+    return r;
+  }
 }