Add a command lazy loading system

Author: sdispater

cleo/application.py

@@ -32,6 +32,7 @@
 from .io.outputs.output import Output
 from .io.outputs.output import Verbosity
 from .io.outputs.stream_output import StreamOutput
+from .loaders.command_loader import CommandLoader
 from .terminal import Terminal
 from .ui.ui import UI
 
@@ -67,6 +68,8 @@ def __init__(self, name: str = "console", version: str = "") -> None:
         # TODO: signals support
         self._event_dispatcher = None
 
+        self._command_loader: Optional[CommandLoader] = None
+
     @property
     def name(self) -> str:
         return self._name
@@ -139,6 +142,9 @@ def set_version(self, version: str) -> None:
     def set_ui(self, ui: UI) -> None:
         self._ui = ui
 
+    def set_command_loader(self, command_loader: CommandLoader) -> None:
+        self._command_loader = command_loader
+
     def auto_exits(self, auto_exits: bool = True) -> None:
         self._auto_exit = auto_exits
 
@@ -203,8 +209,15 @@ def get(self, name: str) -> Command:
     def has(self, name: str) -> bool:
         self._init()
 
-        # TODO: Command loader
-        return name in self._commands
+        if name in self._commands:
+            return True
+
+        if not self._command_loader:
+            return False
+
+        return self._command_loader.has(name) and self.add(
+            self._command_loader.get(name)
+        )
 
     def get_namespaces(self) -> List[str]:
         namespaces = []
@@ -245,7 +258,11 @@ def find(self, name: str) -> Command:
         if self.has(name):
             return self.get(name)
 
-        all_commands = [
+        all_commands = []
+        if self._command_loader:
+            all_commands += self._command_loader.names
+
+        all_commands += [
             name for name, command in self._commands.items() if not command.hidden
         ]
 
@@ -255,16 +272,30 @@ def all(self, namespace: Optional[str] = None) -> Dict[str, Command]:
         self._init()
 
         if namespace is None:
-            # TODO: Command loader
-            return self._commands.copy()
+            commands = self._commands.copy()
+            if not self._command_loader:
+                return commands
+
+            for name in self._command_loader.names:
+                if name not in commands and self.has(name):
+                    commands[name] = self.get(name)
+
+            return commands
 
         commands = {}
 
         for name, command in self._commands.items():
             if namespace == self.extract_namespace(name, name.count(" ") + 1):
                 commands[name] = command
 
-        # TODO: Command loader
+        if self._command_loader:
+            for name in self._command_loader.names:
+                if (
+                    name not in commands
+                    and namespace == self.extract_namespace(name, name.count(" ") + 1)
+                    and self.has(name)
+                ):
+                    commands[name] = self.get(name)
 
         return commands
 

cleo/loaders/__init__.py

@@ -0,0 +1,24 @@
+from typing import List
+
+from cleo.commands.command import Command
+
+
+class CommandLoader:
+    @property
+    def names(self) -> List[str]:
+        """
+        All registered command names.
+        """
+        raise NotImplementedError()
+
+    def get(self, name: str) -> Command:
+        """
+        Loads a command.
+        """
+        raise NotImplementedError()
+
+    def has(self, name: str) -> bool:
+        """
+        Checks whether a command exists or not.
+        """
+        raise NotImplementedError()

cleo/loaders/command_loader.py

@@ -0,0 +1,32 @@
+from typing import Callable
+from typing import Dict
+from typing import List
+
+from cleo.commands.command import Command
+
+from ..exceptions import CommandNotFoundException
+from .command_loader import CommandLoader
+
+
+class FactoryCommandLoader(CommandLoader):
+    """
+    A simple command loader using factories to instantiate commands lazily.
+    """
+
+    def __init__(self, factories: Dict[str, Callable]) -> None:
+        self._factories = factories
+
+    @property
+    def names(self) -> List[str]:
+        return list(self._factories.keys())
+
+    def has(self, name: str) -> bool:
+        return name in self._factories
+
+    def get(self, name: str) -> Command:
+        if name not in self._factories:
+            raise CommandNotFoundException(name)
+
+        factory = self._factories[name]
+
+        return factory()

cleo/loaders/factory_command_loader.py

@@ -0,0 +1,48 @@
+import pytest
+
+from cleo.commands.command import Command
+from cleo.exceptions import CommandNotFoundException
+from cleo.loaders.factory_command_loader import FactoryCommandLoader
+
+
+def command(name: str) -> Command:
+    command_ = Command()
+    command_.name = name
+
+    return command_
+
+
+def test_has():
+    loader = FactoryCommandLoader(
+        {"foo": lambda: command("foo"), "bar": lambda: command("bar")}
+    )
+
+    assert loader.has("foo")
+    assert loader.has("bar")
+    assert not loader.has("baz")
+
+
+def test_get():
+    loader = FactoryCommandLoader(
+        {"foo": lambda: command("foo"), "bar": lambda: command("bar")}
+    )
+
+    assert isinstance(loader.get("foo"), Command)
+    assert isinstance(loader.get("bar"), Command)
+
+
+def test_get_invalid_command_raises_error():
+    loader = FactoryCommandLoader(
+        {"foo": lambda: command("foo"), "bar": lambda: command("bar")}
+    )
+
+    with pytest.raises(CommandNotFoundException):
+        loader.get("baz")
+
+
+def test_names():
+    loader = FactoryCommandLoader(
+        {"foo": lambda: command("foo"), "bar": lambda: command("bar")}
+    )
+
+    assert loader.names == ["foo", "bar"]