feat(cli): wip: make build command build-system agnostic

Author: finswimmer

src/poetry/console/commands/build.py

@@ -3,17 +3,20 @@
 from pathlib import Path
 from typing import TYPE_CHECKING
 from typing import ClassVar
+from typing import Literal
 
 from cleo.helpers import option
 
 from poetry.console.commands.env_command import EnvCommand
-from poetry.utils.env import build_environment
 from poetry.utils.helpers import remove_directory
+from poetry.utils.isolated_build import isolated_builder
 
 
 if TYPE_CHECKING:
     from cleo.io.inputs.option import Option
 
+BUILD_FORMATS = ["sdist", "wheel"]
+
 
 class BuildCommand(EnvCommand):
     name = "build"
@@ -47,49 +50,52 @@ class BuildCommand(EnvCommand):
         "poetry.core.masonry.builders.wheel",
     ]
 
-    def _build(
-        self,
-        fmt: str,
-        executable: str | Path | None = None,
-        *,
-        target_dir: Path | None = None,
-    ) -> None:
-        from poetry.masonry.builders import BUILD_FORMATS
+    def _requested_formats(self) -> list[Literal["sdist", "wheel"]]:
+        fmt = self.option("format") or "all"
 
         if fmt in BUILD_FORMATS:
-            builders = [BUILD_FORMATS[fmt]]
+            formats = [fmt]
         elif fmt == "all":
-            builders = list(BUILD_FORMATS.values())
+            formats = BUILD_FORMATS
         else:
             raise ValueError(f"Invalid format: {fmt}")
 
+        return formats  # type: ignore[return-value]  # TODO
+
+    def _build(
+        self, fmt: Literal["wheel", "sdist"], executable: Path, target_dir: Path
+    ) -> None:
+        config_settings = {}
+
         if local_version_label := self.option("local-version"):
-            self.poetry.package.version = self.poetry.package.version.replace(
-                local=local_version_label
-            )
+            config_settings["local-version"] = local_version_label
 
-        for builder in builders:
-            builder(self.poetry, executable=executable).build(target_dir)
+        with isolated_builder(
+            source=self.poetry.file.path.parent,
+            distribution=fmt,
+            python_executable=executable,
+        ) as builder:
+            self.line(f"Building <info>{fmt}</info>")
+            builder.build(fmt, target_dir, config_settings=config_settings)
 
     def handle(self) -> int:
         if not self.poetry.is_package_mode:
             self.line_error("Building a package is not possible in non-package mode.")
             return 1
 
-        with build_environment(poetry=self.poetry, env=self.env, io=self.io) as env:
-            fmt = self.option("format") or "all"
-            dist_dir = Path(self.option("output"))
-            package = self.poetry.package
-            self.line(
-                f"Building <c1>{package.pretty_name}</c1> (<c2>{package.version}</c2>)"
-            )
+        dist_dir = Path(self.option("output"))
+        package = self.poetry.package
+        self.line(
+            f"Building <c1>{package.pretty_name}</c1> (<c2>{package.version}</c2>)"
+        )
 
-            if not dist_dir.is_absolute():
-                dist_dir = self.poetry.pyproject_path.parent / dist_dir
+        if not dist_dir.is_absolute():
+            dist_dir = self.poetry.pyproject_path.parent / dist_dir
 
-            if self.option("clean"):
-                remove_directory(path=dist_dir, force=True)
+        if self.option("clean"):
+            remove_directory(path=dist_dir, force=True)
 
-            self._build(fmt, executable=env.python, target_dir=dist_dir)
+        for fmt in self._requested_formats():
+            self._build(fmt, executable=self.env.python, target_dir=dist_dir)
 
         return 0