fix(application): handle global options correctly

Previously, the application implementation did not handle global options
correctly when positioned after command options. This lead to incorrect
cached working directory values prior to switching application context.

Resolves: #9978

Author: abn

src/poetry/console/application.py

@@ -4,7 +4,6 @@
 import re
 
 from contextlib import suppress
-from functools import cached_property
 from importlib import import_module
 from pathlib import Path
 from typing import TYPE_CHECKING
@@ -25,6 +24,7 @@
 
 if TYPE_CHECKING:
     from collections.abc import Callable
+    from typing import Any
 
     from cleo.events.event import Event
     from cleo.io.inputs.argv_input import ArgvInput
@@ -103,6 +103,8 @@ def __init__(self) -> None:
         self._disable_plugins = False
         self._disable_cache = False
         self._plugins_loaded = False
+        self._working_directory = Path.cwd()
+        self._project_directory = self._working_directory
 
         dispatcher = EventDispatcher()
         dispatcher.add_listener(COMMAND, self.register_command_loggers)
@@ -156,21 +158,6 @@ def _default_definition(self) -> Definition:
 
         return definition
 
-    @cached_property
-    def _project_directory(self) -> Path:
-        if self._io and self._io.input.option("project"):
-            with directory(self._working_directory):
-                return Path(self._io.input.option("project")).absolute()
-
-        return self._working_directory
-
-    @cached_property
-    def _working_directory(self) -> Path:
-        if self._io and self._io.input.option("directory"):
-            return Path(self._io.input.option("directory")).absolute()
-
-        return Path.cwd()
-
     @property
     def poetry(self) -> Poetry:
         from poetry.factory import Factory
@@ -227,16 +214,55 @@ def create_io(
         return io
 
     def _run(self, io: IO) -> int:
-        self._disable_plugins = io.input.parameter_option("--no-plugins")
-        self._disable_cache = io.input.has_parameter_option("--no-cache")
-
         self._load_plugins(io)
 
         with directory(self._working_directory):
             exit_code: int = super()._run(io)
 
         return exit_code
 
+    def _option_get_value(self, io: IO, name: str, default: Any) -> Any:
+        option = self.definition.option(name)
+
+        if option is None:
+            return default
+
+        values = [f"--{option.name}"]
+
+        if option.shortcut:
+            values.append(f"-{option.shortcut}")
+
+        if not io.input.has_parameter_option(values):
+            return default
+
+        if option.is_flag():
+            return True
+
+        return io.input.parameter_option(values=values, default=default)
+
+    def _configure_custom_application_options(self, io: IO) -> None:
+        if io is None:
+            # nothing to do here then
+            return
+
+        self._disable_plugins = self._option_get_value(
+            io, "no-plugins", self._disable_plugins
+        )
+        self._disable_cache = self._option_get_value(
+            io, "no-cache", self._disable_cache
+        )
+        self._working_directory = self._project_directory = Path(
+            self._option_get_value(io, "directory", Path.cwd())
+        )
+
+        self._project_directory = Path(
+            self._option_get_value(io, "project", self._working_directory)
+        )
+
+        if self._project_directory != self._working_directory:
+            with directory(self._working_directory):
+                self._project_directory = self._project_directory.absolute()
+
     def _configure_io(self, io: IO) -> None:
         # We need to check if the command being run
         # is the "run" command.
@@ -273,6 +299,8 @@ def _configure_io(self, io: IO) -> None:
 
         super()._configure_io(io)
 
+        self._configure_custom_application_options(io)
+
     def register_command_loggers(
         self, event: Event, event_name: str, _: EventDispatcher
     ) -> None:

tests/console/test_application_global_options.py

@@ -0,0 +1,60 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+import pytest
+
+from cleo.testers.application_tester import ApplicationTester
+
+from poetry.console.application import Application
+
+
+if TYPE_CHECKING:
+    from tests.types import FixtureCopier
+
+
+@pytest.fixture
+def project_source_directory(fixture_copier: FixtureCopier) -> Path:
+    return fixture_copier("up_to_date_lock")
+
+
+@pytest.fixture
+def tester() -> ApplicationTester:
+    return ApplicationTester(Application())
+
+
+@pytest.mark.parametrize("parameter", ["-C", "--directory", "-P", "--project"])
+def test_application_global_option_position_does_not_matter(
+    parameter: str, tester: ApplicationTester, project_source_directory: Path
+) -> None:
+    cwd = Path.cwd()
+    assert cwd != project_source_directory
+
+    error_string = "Poetry could not find a pyproject.toml file in"
+
+    # command fails due to lack of pyproject.toml file in cwd
+    tester.execute("show --only main")
+    assert tester.status_code != 0
+
+    stderr = tester.io.fetch_error()
+    assert error_string in stderr
+
+    option = f"{parameter} {project_source_directory.as_posix()}"
+
+    for args in [
+        f"{option} show --only main",
+        f"show {option} --only main",
+        f"show --only main {option}",
+    ]:
+        tester.execute(args)
+        assert tester.status_code == 0
+
+        stdout = tester.io.fetch_output()
+        stderr = tester.io.fetch_error()
+
+        assert error_string not in stderr
+        assert error_string not in stdout
+
+        assert "certifi" in stdout
+        assert len(stdout.splitlines()) == 8