Bash SHELL EXTENSION

📄 Overview

The Bash class inherits from the base Shell class and provides a specialized implementation for command argument formatting. Unlike traditional shell implementations that might concatenate the executable with its arguments, the Bash class delegates argument handling directly to the parent class logic, preventing any premature merging.

This design ensures that the executable path and arguments remain distinct until the final execution layer, offering more flexibility and correctness in complex command building scenarios.

🏛️ Class Definition

The Bash class does not introduce new attributes; instead, it refines the internal command formatting routine. All standard shell operations (execution, environment handling) are inherited from the parent Shell class, while the command assembly logic is customized via the overridden method.

⚙️ Method: _format_command

The method is responsible for formatting the command before it is executed by the shell. In the base Shell class, this method might combine the executable path with the arguments into a single flat list. However, the Bash class deliberately bypasses that concatenation and returns only the arguments as they were received.

Key behavior: The executable parameter is ignored. The method returns the args list as-is. The base Shell class later handles the overall command construction, ensuring that the executable is properly integrated without being merged prematurely.

🧠 Behavioral Logic

The _format_command method implements a clean separation of concerns:

This approach ensures that the Bash class does not impose any custom formatting that would alter the argument sequence. The parent's execution engine will later prepend the executable appropriately, preserving POSIX shell semantics.

📚 Inheritance & Base Shell Contract

The abstract or concrete Shell class defines the following contract for _format_command:

Because the Bash class returns only args, the parent’s command execution routine will typically handle the final command vector as:
final_command = [executable] + self._format_command(executable, args) → which becomes [executable] + args.

💻 Usage Example (Conceptual)

Although the full execution environment is not shown, typical usage of the Bash class inside a shell framework:

from shell_base import Shell
class Bash(Shell):
    def _format_command(self, executable: str, args: list[str]) -> list[str]:
        # returns args untouched → base class handles executable separately
        return args

# hypothetical instantiation
bash_shell = Bash()
# internal execution call would invoke _format_command
formatted = bash_shell._format_command("ls", ["-la", "/home"])
print(formatted)   # Output: ['-la', '/home']
                

Note: The parent Shell class will combine the executable and the returned argument list, ensuring proper command execution.

📑 API Reference

📝 Implementation Notes & Rationale

• No concatenation: The original code comment explicitly states: "We no longer concatenate [executable] + args here." This is a deliberate design shift.
• Delegation to parent: By returning only args, the parent Shell class can handle the executable separately, preserving flexibility for different shell dialects (e.g., sh, zsh).
• Why return args as-is? Prevents double-escaping issues and ensures that argument boundaries are respected. The executable is not treated as part of the argument list prematurely.
• Performance: The method is O(1) in terms of transformation — no copy or list mutation is performed (the same list reference is returned).
• Type safety: Annotations executable: str and args: list[str] improve maintainability and compatibility with static type checkers.