Clean up

Signed-off-by: Alireza Poodineh <[email protected]>

Author: Aeliux

config.py

@@ -6,4 +6,4 @@
 #pybite.Host.SOLUTION_PATH = 'ProjectName.sln'
 
 # Change bite modules folder
-#pybite.Host.MODULES_DIR = 'tools/bite'
+#pybite.Host.MODULES_DIR = 'tools/bite'

tools/pybite/host.py

@@ -4,8 +4,8 @@
 import os
 import platform
 import subprocess
-from typing import Optional, Dict, Any, List, Callable
 import urllib.request
+from typing import Optional, Dict, Any, List, Callable
 
 from .global_json import GlobalJson
 
@@ -17,19 +17,19 @@ class Host:
     """
 
     BASE_DIR: str = os.getcwd()
-    """Base directory for the project (current working directory)."""
+    """Absolute path to the project root."""
 
     MODULES_DIR: str = os.path.join('build', 'modules')
-    """Directory where the bite modules are located."""
+    """Relative or absolute path to the bite modules directory."""
 
     DOTNET_DIR: str = '.dotnet'
-    """Directory where the .NET SDK is or will be installed."""
+    """Relative or absolute path to the .NET SDK directory."""
 
     SOLUTION_PATH: Optional[str] = None
-    """Optional override for the solution path."""
-    
+    """Optional override for the solution (.sln) file."""
+
     BITE_PROJ_PATH: str = 'bite.proj'
-    """Path to the bite.core file."""
+    """Relative or absolute path to the bite.proj file."""
 
     DEFAULT_ARGS: List[str] = ['--nologo']
     """Default arguments to pass to dotnet CLI commands."""
@@ -68,7 +68,7 @@ def __init__(
         self.argparser_usage = f'{self.name} command [options]'
         self.argparser_epilog = "Any unrecognized options will be passed to the command handler."
 
-        # Only join with BASE_DIR if the path is relative
+        # Normalize paths: only join with BASE_DIR if relative
         if not os.path.isabs(self.MODULES_DIR):
             self.MODULES_DIR = os.path.join(self.BASE_DIR, self.MODULES_DIR)
         if not os.path.isabs(self.DOTNET_DIR):
@@ -93,15 +93,17 @@ def __init__(
         self.requested_sdk: Optional[str] = self._resolve_requested_sdk()
         self.solution: str = self.SOLUTION_PATH or self.detect_solution()
         self.argparser: Optional[argparse.ArgumentParser] = None
-        self.handlers: Dict[str, Callable[[argparse.Namespace], None]] = {}
+        self.handlers: Dict[str, Callable[[argparse.Namespace, List[str]], None]] = {}
         self._subparsers_action: Optional[argparse._SubParsersAction] = None
 
+    # --- CLI and Command Registration ---
+
     def get_argparser(self) -> argparse.ArgumentParser:
         """
         Get or create the argument parser for the CLI, using subparsers for each command.
 
         Returns:
-            An argparse.ArgumentParser instance for parsing command-line arguments.
+            argparse.ArgumentParser: The argument parser instance.
         """
         if self.argparser is not None:
             return self.argparser
@@ -113,14 +115,12 @@ def get_argparser(self) -> argparse.ArgumentParser:
             usage=self.argparser_usage,
             add_help=True
         )
-        # Hide the metavar for the subparser argument, but keep help for each command
         subparsers = parser.add_subparsers(
             dest='command',
-            required=False,  # Allow default
-            metavar='',  # This hides the {restore,clean,...} line in help
+            required=False,
+            metavar='',
         )
-        
-        subparsers.required = False  # Explicitly allow no subcommand
+        subparsers.required = False
         parser.set_defaults(command='build', func=self._handle_dotnet_command)
         self._subparsers_action = subparsers
 
@@ -135,6 +135,7 @@ def get_argparser(self) -> argparse.ArgumentParser:
             sub.set_defaults(func=self._handle_dotnet_command)
             self.handlers[cmd['name']] = self._handle_dotnet_command
 
+        # Register bite command only if bite.proj exists
         if os.path.isfile(self.BITE_PROJ_PATH):
             bite_parser = subparsers.add_parser(
                 'bite',
@@ -152,7 +153,7 @@ def get_argparser(self) -> argparse.ArgumentParser:
     def add_command(
         self,
         name: str,
-        handler: Callable[[argparse.Namespace], None],
+        handler: Callable[[argparse.Namespace, List[str]], None],
         description: Optional[str] = None,
         help: str = "",
         arguments: Optional[List[Dict[str, Any]]] = None,
@@ -175,50 +176,83 @@ def add_command(
         if arguments:
             for arg in arguments:
                 sub.add_argument(*arg.get('args', ()), **arg.get('kwargs', {}))
-        # Always allow extra arguments for custom commands
-        sub.add_argument('extras', nargs=argparse.REMAINDER, help='Extra arguments')
         sub.set_defaults(func=handler)
         self.handlers[name] = handler
 
-    def _handle_dotnet_command(self, args: argparse.Namespace, *extras: str) -> None:
+    def register_handler(self, command: str, handler: Callable[[argparse.Namespace, List[str]], None]) -> None:
+        """
+        Register a custom handler for a command.
+
+        Args:
+            command: The command name.
+            handler: The function to handle the command.
+        """
+        self.handlers[command] = handler
+
+    def dispatch(self, args: argparse.Namespace, unknown_args: Optional[List[str]] = None) -> None:
+        """
+        Dispatch the parsed arguments to the appropriate handler.
+
+        Args:
+            args: The parsed argparse.Namespace.
+            unknown_args: List of unknown arguments, if any.
+        """
+        extras = unknown_args or []
+        if hasattr(args, 'func'):
+            args.func(args, extras)
+        else:
+            self.get_argparser().print_help()
+
+    # --- Dotnet/MSBuild Command Handlers ---
+
+    def _handle_dotnet_command(self, args: argparse.Namespace, extras: List[str]) -> None:
         """
-        Handle standard dotnet commands: restore, clean, build, test.
+        Handle standard dotnet commands: restore, clean, build, test, pack.
         Passes any extra arguments to the dotnet CLI.
         """
         self.run(args.command, *extras)
 
-    def _handle_bite(self, args: argparse.Namespace, *extras: str) -> None:
+    def _handle_bite(self, args: argparse.Namespace, extras: List[str]) -> None:
         """
         Handle the 'bite' command, running a custom msbuild target.
         Passes any extra arguments to msbuild.
         """
         target = getattr(args, 'target', 'help')
         self.run_bite(target, *extras)
 
-    def register_handler(self, command: str, handler: Callable[[argparse.Namespace], None]) -> None:
+    # --- Dotnet/MSBuild Execution ---
+
+    def run(self, command: str, *args: str) -> None:
         """
-        Register a custom handler for a command.
+        Run a dotnet command with the solution file as an argument.
 
         Args:
-            command: The command name.
-            handler: The function to handle the command.
+            command: The dotnet CLI command to run (e.g., 'build', 'restore').
+            *args: Additional arguments to pass to the command.
         """
-        self.handlers[command] = handler
+        cmd = ['dotnet', command] + [self.solution] + self.DEFAULT_ARGS + list(args)
+        try:
+            subprocess.check_call(cmd)
+        except subprocess.CalledProcessError as e:
+            print(f"Error: dotnet {command} failed with exit code {e.returncode}")
+            raise
 
-    def dispatch(self, args: argparse.Namespace, unknown_args: Optional[List[str]] = None) -> None:
+    def run_bite(self, target: str, *args: str) -> None:
         """
-        Dispatch the parsed arguments to the appropriate handler.
+        Run bite.core with the specified target.
 
         Args:
-            args: The parsed argparse.Namespace.
-            unknown_args: List of unknown arguments, if any.
+            target: The bite.core target to run.
+            *args: Additional arguments to pass to msbuild.
         """
-        extras = unknown_args or []
+        cmd = ['dotnet', 'msbuild'] + self.DEFAULT_ARGS + [f'-t:{target}', self.BITE_PROJ_PATH] + list(args)
+        try:
+            subprocess.check_call(cmd)
+        except subprocess.CalledProcessError as e:
+            print(f"Error: msbuild target '{target}' failed with exit code {e.returncode}")
+            raise
 
-        if hasattr(args, 'func'):
-            args.func(args, *extras)
-        else:
-            self.get_argparser().print_help()
+    # --- SDK Installation ---
 
     def _set_environment_variables(self) -> None:
         """
@@ -249,15 +283,13 @@ def _install_sdk_windows(self) -> None:
         """
         if self.requested_sdk is None:
             raise RuntimeError("No .NET SDK install required")
-        
+
         installer = os.path.join(self.DOTNET_DIR, 'dotnet-install.ps1')
         url = 'https://dot.net/v1/dotnet-install.ps1'
 
-        # Download the PowerShell script using urllib
         with urllib.request.urlopen(url) as response, open(installer, 'wb') as out_file:
             out_file.write(response.read())
 
-        # Run the installer script
         subprocess.check_call([
             'powershell', '-NoProfile', '-ExecutionPolicy', 'Bypass',
             installer,
@@ -271,30 +303,29 @@ def _install_sdk_unix(self) -> None:
         """
         if self.requested_sdk is None:
             raise RuntimeError("No .NET SDK install required")
-        
+
         installer = os.path.join(self.DOTNET_DIR, 'dotnet-install.sh')
         url = 'https://dot.net/v1/dotnet-install.sh'
 
-        # Download the Bash script using urllib
         with urllib.request.urlopen(url) as response, open(installer, 'wb') as out_file:
             out_file.write(response.read())
 
-        # Make the script executable
         os.chmod(installer, 0o755)
 
-        # Run the installer script
         subprocess.check_call([
             'bash', installer,
             '--version', self.requested_sdk,
             '--install-dir', self.DOTNET_DIR
         ])
 
+    # --- Solution/SDK Detection ---
+
     def detect_solution(self) -> str:
         """
         Find the single .sln file in BASE_DIR and return its full path.
 
         Returns:
-            The full path to the solution file.
+            str: The full path to the solution file.
 
         Raises:
             RuntimeError: If zero or multiple .sln files are found.
@@ -311,7 +342,7 @@ def _resolve_requested_sdk(self) -> Optional[str]:
         Determine if the required SDK is installed.
 
         Returns:
-            The required version if installation is needed, otherwise None.
+            Optional[str]: The required version if installation is needed, otherwise None.
         """
         required = (
             self.global_json.version
@@ -329,27 +360,7 @@ def _resolve_requested_sdk(self) -> Optional[str]:
         except (subprocess.CalledProcessError, FileNotFoundError):
             return required
 
-    def run(self, command: str, *args: str) -> None:
-        """
-        Run a dotnet command with the solution file as an argument.
-
-        Args:
-            command: The dotnet CLI command to run (e.g., 'build', 'restore').
-            *args: Additional arguments to pass to the command.
-        """
-        cmd = ['dotnet', command] + [self.solution] + self.DEFAULT_ARGS + list(args)
-        subprocess.call(cmd)
-
-    def run_bite(self, target: str, *args: str) -> None:
-        """
-        Run bite.core with the specified target.
-
-        Args:
-            target: The bite.core target to run.
-            *args: Additional arguments to pass to msbuild.
-        """
-        cmd = ['dotnet', 'msbuild'] + self.DEFAULT_ARGS + [f'-t:{target}', self.BITE_PROJ_PATH] + list(args)
-        subprocess.call(cmd)
+    # --- Utility ---
 
     @staticmethod
     def msbuild_path(path: str) -> str:
@@ -370,7 +381,7 @@ def load_modules(self) -> Dict[str, Any]:
         Load all .bite.py modules from the modules directory.
 
         Returns:
-            A dictionary mapping plugin names to loaded module objects.
+            Dict[str, Any]: Mapping of plugin names to loaded module objects.
         """
         mods: Dict[str, Any] = {}
         pattern = os.path.join(self.MODULES_DIR, '**', '*.bite.py')
@@ -379,10 +390,15 @@ def load_modules(self) -> Dict[str, Any]:
             spec = importlib.util.spec_from_file_location(name, path)
             if spec is None or spec.loader is None:
                 continue
-
             mod = importlib.util.module_from_spec(spec)
-            spec.loader.exec_module(mod)
-            
+            try:
+                spec.loader.exec_module(mod)
+            except Exception as e:
+                print(f"Failed to load module {name} from {path}: {e}")
+                continue
             if hasattr(mod, 'load'):
-                mods[name] = mod.load(self)
+                try:
+                    mods[name] = mod.load(self)
+                except Exception as e:
+                    print(f"Module '{name}' failed to initialize: {e}")
         return mods