Reimplement alias merging algorithm

Author: zooba

src/manage/install_command.py

@@ -344,37 +344,33 @@ def print_cli_shortcuts(cmd):
             LOGGER.debug("Failed to display PATH warning", exc_info=True)
             return
 
+    from .installs import get_install_alias_names
     installs = cmd.get_installs()
     tags = getattr(cmd, "tags", None)
     seen = set("python.exe".casefold())
     verbose = LOGGER.would_log_to_console(VERBOSE)
     for i in installs:
-        # We only show windowed aliases if -v is enabled. But we log them as
-        # debug info unconditionally. This involves a bit of a dance to keep the
-        # 'windowed' flag around and then drop entries based on whether
-        # LOGGER.verbose would be printed to the console.
-        aliases = sorted((a["name"], a.get("windowed", 0)) for a in i["alias"]
-                         if a["name"].casefold() not in seen)
-        seen.update(n.casefold() for n, *_ in aliases)
+        # We need to pre-filter aliases before getting the nice names.
+        aliases = [a for a in i["alias"] if a["name"].casefold() not in seen]
+        seen.update(n["name"].casefold() for n in aliases)
         if not verbose:
             if i.get("default"):
                 LOGGER.debug("%s will be launched by !G!python.exe!W!", i["display-name"])
-            LOGGER.debug("%s will be launched by %s", i["display-name"],
-                         ", ".join([n for n, *_ in aliases]))
-            aliases = [n for n, w in aliases if not w]
-        else:
-            aliases = [n for n, *_ in aliases]
+            names = get_install_alias_names(aliases, windowed=True)
+            LOGGER.debug("%s will be launched by %s", i["display-name"], ", ".join(names))
 
         if tags and not install_matches_any(i, cmd.tags):
             continue
-        if i.get("default") and aliases:
+
+        names = get_install_alias_names(aliases, windowed=False)
+        if i.get("default") and names:
             LOGGER.info("%s will be launched by !G!python.exe!W! and also %s",
-                        i["display-name"], ", ".join(aliases))
+                        i["display-name"], ", ".join(names))
         elif i.get("default"):
             LOGGER.info("%s will be launched by !G!python.exe!W!.", i["display-name"])
-        elif aliases:
+        elif names:
             LOGGER.info("%s will be launched by %s",
-                        i["display-name"], ", ".join(aliases))
+                        i["display-name"], ", ".join(names))
         else:
             LOGGER.info("Installed %s to %s", i["display-name"], i["prefix"])
 

src/manage/installs.py

@@ -120,6 +120,62 @@ def get_installs(
     return installs
 
 
+def _make_alias_key(alias):
+    from .tagutils import SUPPORTED_PLATFORM_SUFFIXES
+    n1, sep, n3 = alias.rpartition(".")
+    n2 = ""
+    n3 = sep + n3
+    if n1.endswith(SUPPORTED_PLATFORM_SUFFIXES):
+        n1, sep, plat = n1.rpartition("-")
+        plat = sep + plat
+    else:
+        plat = ""
+
+    while n1 and n1[-1] in "0123456789.-":
+        n2 = n1[-1] + n2
+        n1 = n1[:-1]
+    w = ""
+    if n1 and n1[-1] == "w":
+        w = "w"
+        n1 = n1[:-1]
+    return n1, w, n2, plat, n3
+
+
+def _make_opt_part(parts):
+    if not parts:
+        return ""
+    if len(parts) == 1:
+        return list(parts)[0]
+    return "[{}]".format("|".join(sorted(p for p in parts if p)))
+
+
+def get_install_alias_names(aliases, friendly=True, windowed=True):
+    if not windowed:
+        aliases = [a for a in aliases if not a.get("windowed")]
+    if not friendly:
+        return sorted(a["name"] for a in aliases)
+
+    seen = {}
+    has_w = {}
+    plats = {}
+    for n1, w, n2, plat, n3 in (_make_alias_key(a["name"]) for a in aliases):
+        k = n1.casefold(), n2.casefold(), n3.casefold()
+        seen.setdefault(k, (n1, n2, n3))
+        has_w.setdefault(k, set()).add(w)
+        plats.setdefault(k, set()).add(plat)
+
+    result = []
+    for k, (n1, n2, n3) in seen.items():
+        result.append("".join([
+            n1,
+            _make_opt_part(has_w.get(k)),
+            n2,
+            _make_opt_part(plats.get(k)),
+            n3,
+        ]))
+    return sorted(result)
+
+
 def _patch_install_to_run(i, run_for):
     return {
         **i,

src/manage/list_command.py

@@ -7,43 +7,11 @@
 LOGGER = logging.LOGGER
 
 
-def _exe_partition(n):
-    n1, sep, n2 = n.rpartition(".")
-    n2 = sep + n2
-    while n1 and n1[-1] in "0123456789.-":
-        n2 = n1[-1] + n2
-        n1 = n1[:-1]
-    w = ""
-    if n1 and n1[-1] == "w":
-        w = "w"
-        n1 = n1[:-1]
-    return n1, w, n2
-
-
 def _format_alias(i, seen):
-    try:
-        alias = i["alias"]
-    except KeyError:
-        return ""
-    if not alias:
-        return ""
-    if len(alias) == 1:
-        a = i["alias"][0]
-        n = a["name"].casefold()
-        if n in seen:
-            return ""
-        seen.add(n)
-        return i["alias"][0]["name"]
-    names = {_exe_partition(a["name"].casefold()): a["name"] for a in alias
-             if a["name"].casefold() not in seen}
-    seen.update(a["name"].casefold() for a in alias)
-    for n1, w, n2 in list(names):
-        k = (n1, "", n2)
-        if w and k in names:
-            del names[n1, w, n2]
-            n1, _, n2 = _exe_partition(names[k])
-            names[k] = f"{n1}[w]{n2}"
-    return ", ".join(names[n] for n in sorted(names))
+    from manage.installs import get_install_alias_names
+    aliases = [a for a in i.get("alias", ()) if a["name"].casefold() not in seen]
+    seen.update(a["name"].casefold() for a in aliases)
+    return ", ".join(get_install_alias_names(aliases))
 
 
 def _format_tag_with_co(cmd, i):