invoke-toolkit 0.0.62__tar.gz → 0.0.63__tar.gz

{invoke_toolkit-0.0.62 → invoke_toolkit-0.0.63}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: invoke-toolkit
-Version: 0.0.62
+Version: 0.0.63
 Summary: Extended APIs for PyInvoke: composable task plugins, typed CLI args, Rich output, shell completion, and PEP 723 script support
 Project-URL: Documentation, https://github.com/D3f0/invoke-toolkit#readme
 Project-URL: Issues, https://github.com/D3f0/invoke-toolkit/issues
@@ -36,7 +36,7 @@ Requires-Dist: appdirs
 Requires-Dist: attrs>=24.1.0
 Requires-Dist: cattrs>=24.1.0
 Requires-Dist: httpx>=0.28.1
-Requires-Dist: invoke>=2.2.1
+Requires-Dist: invoke>=3.0.3
 Requires-Dist: platformdirs>=4.5.0
 Requires-Dist: pyyaml>=6.0.3
 Requires-Dist: rich>=13

{invoke_toolkit-0.0.62 → invoke_toolkit-0.0.63}/pyproject.toml

@@ -45,7 +45,7 @@ classifiers = [
   "Typing :: Typed",
 ]
 dependencies = [
-    "invoke>=2.2.1",
+    "invoke>=3.0.3",
     "rich>=13",
     "typing-extensions>=4.13.2",
     "appdirs",

{invoke_toolkit-0.0.62 → invoke_toolkit-0.0.63}/src/invoke_toolkit/context/context.py

@@ -70,8 +70,10 @@ class ToolkitContext(Context, ConfigProtocol):
         [Union[PathLike[str], str]], _GeneratorContextManager[None, None, None]
     ]
 
-    def __init__(self, config: Optional[ToolkitConfig] = None) -> None:
-        super().__init__(config)
+    def __init__(
+        self, config: Optional[ToolkitConfig] = None, remainder: str = ""
+    ) -> None:
+        super().__init__(config, remainder=remainder)
         self._set("_console", get_console())
         # Check if status is disabled in the config
         disabled = False

{invoke_toolkit-0.0.62 → invoke_toolkit-0.0.63}/src/invoke_toolkit/executor.py

@@ -39,11 +39,16 @@ class ToolkitExecutor(Executor):
 
         :param core:
             An optional `.ParseResult` holding parsed core program arguments.
-            Defaults to ``None``.
+            Defaults to an empty `.ParseResult` if not given.
+
+        .. versionchanged:: invoke 3.0
+            ``self.core`` now defaults to ``ParseResult()`` instead of
+            ``None``, matching upstream ``Executor`` behaviour and ensuring
+            ``core_parse_result.remainder`` is always accessible.
         """
         self.collection = collection
         self.config = config if config is not None else ToolkitConfig()
-        self.core = core
+        self.core = core if core is not None else ParseResult()
 
     def execute(
         self, *tasks: Union[str, Tuple[str, Dict[str, Any]], ParserContext]
@@ -134,7 +139,7 @@ class ToolkitExecutor(Executor):
             # Get final context from the Call (which will know how to generate
             # an appropriate one; e.g. subclasses might use extra data from
             # being parameterized), handing in this config for use there.
-            context = call.make_context(config)  # type: ignore[attr-defined]
+            context = call.make_context(config, core_parse_result=self.core)  # type: ignore[attr-defined]
             args = (context, *call.args)  # type: ignore[attr-defined]
             result = call.task(*args, **call.kwargs)  # type: ignore[attr-defined]
             if autoprint:

{invoke_toolkit-0.0.62 → invoke_toolkit-0.0.63}/src/invoke_toolkit/tasks/tasks.py

@@ -2,7 +2,7 @@
 Type annotated tasks and and overrides over invoke
 """
 
-# pylint: disable=too-many-statements
+# pylint: disable=too-many-statements,duplicate-code
 
 import inspect
 import os
@@ -822,9 +822,16 @@ def task(  # pylint: disable=too-many-arguments,too-many-branches
 
 
 class ToolkitCall(Call):
-    def make_context(self, config):
-        """Generates the Context for the task"""
-        return ToolkitContext(config=config)
+    def make_context(self, config, core_parse_result=None):
+        """Generates the Context for the task.
+
+        .. versionchanged:: invoke 3.0
+            Added the ``core_parse_result`` parameter so that
+            ``Context.remainder`` is populated from the CLI parser's remainder
+            value (text after a standalone ``--``).
+        """
+        remainder = core_parse_result.remainder if core_parse_result is not None else ""
+        return ToolkitContext(config=config, remainder=remainder)
 
 
 def call(task_: "Task", *args: Any, **kwargs: Any) -> "Call":

invoke_toolkit-0.0.63/tests/test_invoke_3_compat.py

@@ -0,0 +1,184 @@
+"""
+Tests for invoke 3.0.x compatibility.
+
+invoke 3.0 introduced two related breaking changes that affect invoke-toolkit:
+
+1. ``Call.make_context`` now requires a second argument ``core_parse_result``
+   (a ``ParseResult`` instance) so that ``Context.remainder`` can be populated
+   from the CLI parser's remainder value (text after a standalone ``--``).
+
+2. ``Context.__init__`` now accepts a ``remainder`` keyword argument and stores
+   it as ``self.remainder``.
+
+These tests verify that:
+- ``ToolkitCall.make_context`` accepts ``core_parse_result`` and propagates
+  ``remainder`` into the resulting ``ToolkitContext``.
+- ``ToolkitContext`` exposes ``ctx.remainder`` correctly.
+- ``ToolkitExecutor`` never passes ``None`` as ``core_parse_result`` (it
+  defaults to an empty ``ParseResult()``).
+- End-to-end: a task can read ``ctx.remainder`` when invoked with ``-- extra``.
+"""
+
+from invoke.parser import ParseResult
+from invoke.tasks import Task
+
+from invoke_toolkit import Context, task
+from invoke_toolkit.collections import ToolkitCollection
+from invoke_toolkit.config import ToolkitConfig
+from invoke_toolkit.context.context import ToolkitContext
+from invoke_toolkit.executor import ToolkitExecutor
+from invoke_toolkit.tasks.tasks import ToolkitCall
+
+
+# ---------------------------------------------------------------------------
+# Unit: ToolkitCall.make_context
+# ---------------------------------------------------------------------------
+
+
+def _dummy_task_func(ctx: Context) -> None:  # pragma: no cover
+    """Minimal real task used as a ToolkitCall target in unit tests."""
+
+
+_DUMMY_TASK: Task = task(_dummy_task_func)  # type: ignore[assignment]
+
+
+def _make_parse_result(remainder: str = "") -> ParseResult:
+    """Return a ParseResult whose .remainder is set to *remainder*."""
+    pr = ParseResult()
+    pr.remainder = remainder
+    return pr
+
+
+def test_make_context_without_core_parse_result():
+    """make_context(config) with no core_parse_result → remainder defaults to ''."""
+    config = ToolkitConfig()
+    c = ToolkitCall(_DUMMY_TASK)
+    ctx = c.make_context(config)
+    assert isinstance(ctx, ToolkitContext)
+    assert ctx.remainder == ""
+
+
+def test_make_context_with_empty_parse_result():
+    """make_context(config, core_parse_result=ParseResult()) → remainder is ''."""
+    config = ToolkitConfig()
+    c = ToolkitCall(_DUMMY_TASK)
+    ctx = c.make_context(config, core_parse_result=_make_parse_result(""))
+    assert isinstance(ctx, ToolkitContext)
+    assert ctx.remainder == ""
+
+
+def test_make_context_propagates_remainder():
+    """make_context passes ParseResult.remainder into ToolkitContext.remainder."""
+    config = ToolkitConfig()
+    c = ToolkitCall(_DUMMY_TASK)
+    ctx = c.make_context(config, core_parse_result=_make_parse_result("extra args"))
+    assert ctx.remainder == "extra args"
+
+
+def test_make_context_with_none_core_parse_result():
+    """Passing core_parse_result=None explicitly is safe (backward compat)."""
+    config = ToolkitConfig()
+    c = ToolkitCall(_DUMMY_TASK)
+    ctx = c.make_context(config, core_parse_result=None)
+    assert ctx.remainder == ""
+
+
+# ---------------------------------------------------------------------------
+# Unit: ToolkitContext.__init__
+# ---------------------------------------------------------------------------
+
+
+def test_toolkit_context_remainder_default():
+    """ToolkitContext() has remainder='' by default."""
+    ctx = ToolkitContext()
+    assert ctx.remainder == ""
+
+
+def test_toolkit_context_remainder_kwarg():
+    """ToolkitContext(remainder=...) stores the value on the instance."""
+    ctx = ToolkitContext(remainder="docker run --rm alpine")
+    assert ctx.remainder == "docker run --rm alpine"
+
+
+def test_toolkit_context_remainder_with_config():
+    """ToolkitContext(config=..., remainder=...) works with both args."""
+    config = ToolkitConfig()
+    ctx = ToolkitContext(config=config, remainder="--verbose")
+    assert ctx.remainder == "--verbose"
+
+
+# ---------------------------------------------------------------------------
+# Unit: ToolkitExecutor.__init__
+# ---------------------------------------------------------------------------
+
+
+def test_executor_core_defaults_to_parse_result():
+    """ToolkitExecutor.core is never None; defaults to ParseResult()."""
+    col = ToolkitCollection()
+    executor = ToolkitExecutor(collection=col)
+    assert executor.core is not None
+    assert isinstance(executor.core, ParseResult)
+
+
+def test_executor_core_accepts_explicit_parse_result():
+    """ToolkitExecutor.core stores an explicitly provided ParseResult."""
+    col = ToolkitCollection()
+    pr = _make_parse_result("some remainder")
+    executor = ToolkitExecutor(collection=col, core=pr)
+    assert executor.core is pr
+    assert executor.core.remainder == "some remainder"
+
+
+def test_executor_core_none_becomes_empty_parse_result():
+    """Passing core=None explicitly still yields a ParseResult(), not None."""
+    col = ToolkitCollection()
+    executor = ToolkitExecutor(collection=col, core=None)
+    assert executor.core is not None
+    assert isinstance(executor.core, ParseResult)
+    assert executor.core.remainder == ""
+
+
+# ---------------------------------------------------------------------------
+# Integration: ctx.remainder is accessible inside a task
+# ---------------------------------------------------------------------------
+
+
+def test_task_receives_remainder_via_context():
+    """A task can read ctx.remainder when the program is given a remainder."""
+    captured: list[str] = []
+
+    ns = ToolkitCollection()
+
+    @task  # type: ignore[arg-type]
+    def wrapper_task(ctx: Context):
+        """Wrapper task that captures ctx.remainder."""
+        captured.append(ctx.remainder)
+
+    ns.add_task(wrapper_task)  # type: ignore[arg-type]
+
+    pr = _make_parse_result("echo hello world")
+    config = ToolkitConfig()
+    executor = ToolkitExecutor(collection=ns, config=config, core=pr)
+    executor.execute("wrapper-task")
+
+    assert len(captured) == 1
+    assert captured[0] == "echo hello world"
+
+
+def test_task_remainder_empty_when_not_provided():
+    """ctx.remainder is '' when no remainder was parsed."""
+    captured: list[str] = []
+
+    ns = ToolkitCollection()
+
+    @task  # type: ignore[arg-type]
+    def simple_task(ctx: Context):
+        """Simple task that captures ctx.remainder."""
+        captured.append(ctx.remainder)
+
+    ns.add_task(simple_task)  # type: ignore[arg-type]
+
+    executor = ToolkitExecutor(collection=ns)
+    executor.execute("simple-task")
+
+    assert captured == [""]