Implement Tool base class

changes/1093.misc.rst

@@ -0,0 +1 @@
+The ``Tool`` and ``ManagedTool`` base classes were implemented to unify tool functionality.

src/briefcase/commands/create.py

@@ -22,7 +22,7 @@
     TemplateUnsupportedVersion,
     UnsupportedPlatform,
 )
-from briefcase.integrations import git
+from briefcase.integrations.git import Git
 from briefcase.integrations.subprocess import NativeAppContext
 
 from .base import BaseCommand, full_options
@@ -811,7 +811,7 @@ def verify_tools(self):
         Raises MissingToolException if a required system tool is missing.
         """
         super().verify_tools()
-        git.verify_git_is_installed(tools=self.tools)
+        Git.verify(tools=self.tools)
 
     def verify_app_tools(self, app: BaseConfig):
         """Verify that tools needed to run the command for this app exist."""

src/briefcase/commands/new.py

@@ -13,7 +13,7 @@
     make_class_name,
 )
 from briefcase.exceptions import BriefcaseCommandError, TemplateUnsupportedVersion
-from briefcase.integrations import git
+from briefcase.integrations.git import Git
 
 from .base import BaseCommand
 
@@ -519,7 +519,7 @@ def verify_tools(self):
         Raises MissingToolException if a required system tool is missing.
         """
         super().verify_tools()
-        git.verify_git_is_installed(tools=self.tools)
+        Git.verify(tools=self.tools)
 
     def __call__(
         self,

src/briefcase/commands/upgrade.py

@@ -1,12 +1,13 @@
 import sys
-from typing import List
+from operator import attrgetter
+from typing import List, Set, Type
 
-from briefcase.exceptions import BriefcaseCommandError
-from briefcase.integrations.android_sdk import AndroidSDK
-from briefcase.integrations.java import JDK
-from briefcase.integrations.linuxdeploy import LinuxDeploy
-from briefcase.integrations.rcedit import RCEdit
-from briefcase.integrations.wix import WiX
+from briefcase.exceptions import (
+    BriefcaseCommandError,
+    UnsupportedHostError,
+    UpgradeToolError,
+)
+from briefcase.integrations.base import ManagedTool, Tool, tool_registry
 
 from .base import BaseCommand
 
@@ -17,16 +18,6 @@ class UpgradeCommand(BaseCommand):
     output_format = None
     description = "Upgrade Briefcase-managed tools."
 
-    def __init__(self, *args, **options):
-        super().__init__(*args, **options)
-        self.sdks = [
-            AndroidSDK,
-            LinuxDeploy,
-            JDK,
-            WiX,
-            RCEdit,
-        ]
-
     @property
     def platform(self):
         """The upgrade command always reports as the local platform."""
@@ -59,62 +50,67 @@ def add_options(self, parser):
             help="The Briefcase-managed tool to upgrade. If no tool is named, all tools will be upgraded.",
         )
 
-    def __call__(self, tool_list: List[str], list_tools=False, **options):
-        # Verify all the managed SDKs and plugins to see which are present.
-        managed_tools = {}
-        non_managed_tools = set()
-
-        for klass in self.sdks:
-            try:
-                tool = klass.verify(self.tools, install=False)
-                if tool.managed_install:
-                    managed_tools[klass.name] = tool
-                    try:
-                        for plugin_klass in tool.plugins.values():
-                            try:
-                                plugin = plugin_klass.verify(self.tools, install=False)
-                                # All plugins are managed
-                                managed_tools[plugin.name] = plugin
-                            except BriefcaseCommandError:
-                                # Plugin doesn't exist
-                                non_managed_tools.add(klass.name)
-                    except AttributeError:
-                        # Tool doesn't have plugins
-                        pass
+    def get_tools_to_upgrade(self, tool_list: Set[str]) -> List[ManagedTool]:
+        """Returns set of managed Tools that can be upgraded.
+
+        Raises ``BriefcaseCommandError`` if user list contains any invalid tool names.
+        """
+        upgrade_list: set[Type[Tool]]
+        tools_to_upgrade: set[ManagedTool] = set()
+
+        # Validate user tool list against tool registry
+        if tool_list:
+            if invalid_tools := tool_list - set(tool_registry):
+                raise UpgradeToolError(
+                    f"Briefcase does not know how to manage {', '.join(sorted(invalid_tools))}."
+                )
+            upgrade_list = {
+                tool for name, tool in tool_registry.items() if name in tool_list
+            }
+        else:
+            upgrade_list = set(tool_registry.values())
+
+        # Filter list of tools to those that are being managed
+        for tool_klass in upgrade_list:
+            if issubclass(tool_klass, ManagedTool):
+                try:
+                    tool = tool_klass.verify(tools=self.tools, install=False)
+                except (BriefcaseCommandError, UnsupportedHostError):
+                    pass
                 else:
-                    non_managed_tools.add(klass.name)
-            except BriefcaseCommandError:
-                # Tool doesn't exist
-                non_managed_tools.add(klass.name)
-
-        # If a tool list wasn't provided, use the list of installed tools
-        if not tool_list:
-            tool_list = sorted(managed_tools.keys())
-
-        # Build a list of requested tools that are managed.
-        found_tools = []
-        for name in tool_list:
-            if name in managed_tools:
-                found_tools.append(name)
-            elif name not in non_managed_tools:
-                raise BriefcaseCommandError(
-                    f"Briefcase doesn't know how to manage the tool '{name}'"
+                    if tool.managed_install:
+                        tools_to_upgrade.add(tool)
+
+        # Let the user know if any requested tools are not being managed
+        if tool_list:
+            if unmanaged_tools := tool_list - {tool.name for tool in tools_to_upgrade}:
+                error_msg = (
+                    f"Briefcase is not managing {', '.join(sorted(unmanaged_tools))}."
                 )
-
-        if found_tools:
-            if list_tools:
-                self.logger.info("Briefcase is managing the following tools:")
-                for name in found_tools:
-                    self.logger.info(f" - {name}")
-            else:
-                self.logger.info("Briefcase will upgrade the following tools:")
-                for name in found_tools:
-                    self.logger.info(f" - {name}")
-
-                for name in found_tools:
-                    tool = managed_tools[name]
+                if not tools_to_upgrade:
+                    raise UpgradeToolError(error_msg)
+                else:
+                    self.logger.warning(error_msg)
+
+        return sorted(list(tools_to_upgrade), key=attrgetter("name"))
+
+    def __call__(self, tool_list: List[str], list_tools: bool = False, **options):
+        """Perform tool upgrades or list tools qualifying for upgrade.
+
+        :param tool_list: List of tool names from user to upgrade.
+        :param list_tools: Boolean to only list upgradeable tools (default False).
+        """
+        if tools_to_upgrade := self.get_tools_to_upgrade(set(tool_list)):
+            self.logger.info(
+                f"Briefcase {'is managing' if list_tools else 'will upgrade'} the following tools:",
+                prefix=self.command,
+            )
+            for tool in tools_to_upgrade:
+                self.logger.info(f" - {tool.full_name} ({tool.name})")
+
+            if not list_tools:
+                for tool in tools_to_upgrade:
                     self.logger.info(f"Upgrading {tool.full_name}...", prefix=tool.name)
                     tool.upgrade()
-
         else:
             self.logger.info("Briefcase is not managing any tools.")

src/briefcase/exceptions.py

@@ -70,8 +70,8 @@ def __str__(self):
 
 
 class BriefcaseCommandError(BriefcaseError):
-    def __init__(self, msg):
-        super().__init__(error_code=200)
+    def __init__(self, msg, skip_logfile=False):
+        super().__init__(error_code=200, skip_logfile=skip_logfile)
         self.msg = msg
 
     def __str__(self):
@@ -109,6 +109,11 @@ def __init__(self, tool):
         super().__init__(msg=f"{tool!r} is using an install that is user managed.")
 
 
+class UpgradeToolError(BriefcaseCommandError):
+    def __init__(self, error_msg):
+        super().__init__(msg=error_msg, skip_logfile=True)
+
+
 class TemplateUnsupportedVersion(BriefcaseCommandError):
     def __init__(self, briefcase_version):
         self.briefcase_version = briefcase_version