ENH: add support for editable installs

Signed-off-by: Filipe Laíns <[email protected]>

Author: FFY00

mesonpy/__init__.py

@@ -12,6 +12,7 @@
 
 import collections
 import contextlib
+import dataclasses
 import functools
 import importlib.machinery
 import io
@@ -497,24 +498,27 @@ def _install_path(
 
             wheel_file.write(origin, location)
 
+    def _wheel_write_metadata(self, whl: mesonpy._wheelfile.WheelFile, editable: bool = False) -> None:
+        # add metadata
+        whl.writestr(f'{self.distinfo_dir}/METADATA', self._project.metadata(editable))
+        whl.writestr(f'{self.distinfo_dir}/WHEEL', self.wheel)
+        if self.entrypoints_txt:
+            whl.writestr(f'{self.distinfo_dir}/entry_points.txt', self.entrypoints_txt)
+
+        # add license (see https://github.com/mesonbuild/meson-python/issues/88)
+        if self._project.license_file:
+            whl.write(
+                self._source_dir / self._project.license_file,
+                f'{self.distinfo_dir}/{os.path.basename(self._project.license_file)}',
+            )
+
     def build(self, directory: Path) -> pathlib.Path:
         self._project.build()  # ensure project is built
 
         wheel_file = pathlib.Path(directory, f'{self.name}.whl')
 
         with mesonpy._wheelfile.WheelFile(wheel_file, 'w') as whl:
-            # add metadata
-            whl.writestr(f'{self.distinfo_dir}/METADATA', self._project.metadata)
-            whl.writestr(f'{self.distinfo_dir}/WHEEL', self.wheel)
-            if self.entrypoints_txt:
-                whl.writestr(f'{self.distinfo_dir}/entry_points.txt', self.entrypoints_txt)
-
-            # add license (see https://github.com/mesonbuild/meson-python/issues/88)
-            if self._project.license_file:
-                whl.write(
-                    self._source_dir / self._project.license_file,
-                    f'{self.distinfo_dir}/{os.path.basename(self._project.license_file)}',
-                )
+            self._wheel_write_metadata(whl)
 
             print('{light_blue}{bold}Copying files to wheel...{reset}'.format(**_STYLES))
             with mesonpy._util.cli_counter(
@@ -542,7 +546,49 @@ def build(self, directory: Path) -> pathlib.Path:
         return wheel_file
 
     def build_editable(self, directory: Path) -> pathlib.Path:
-        self._build()
+        self._project.build()  # ensure project is built
+
+        wheel_file = pathlib.Path(directory, f'{self.name}.whl')
+
+        project_path = self._source_dir / '.mesonpy-editable'
+        top_level_modules = self._project.top_level_modules
+        rebuild_commands = [list(cmd) for cmd in self._project.build_commands(project_path)]
+
+        with mesonpy._wheelfile.WheelFile(wheel_file, 'w') as whl:
+            self._wheel_write_metadata(whl, editable=True)
+            whl.writestr(
+                f'{self.distinfo_dir}/direct_url.json.py',
+                f'file://{os.fspath(self._project.source_dir)}'.encode(),
+            )
+
+            # install hook module
+            hook_module_name = f'_mesonpy_hook_{self.normalized_name.replace(".", "_")}'
+            whl.writestr(
+                f'{hook_module_name}.py',
+                textwrap.dedent(f'''
+                    import mesonpy._editable
+                    mesonpy._editable.MesonpyFinder.install(
+                        project_path={project_path},
+                        top_level_modules={top_level_modules},
+                        rebuild_commands={rebuild_commands},
+                    )
+                ''').strip().encode(),
+            )
+            # install .pth file
+            whl.writestr(
+                f'_mesonpy_{self.normalized_name}.pth',
+                f'import {hook_module_name}'.encode(),
+            )
+
+            # install non-code schemes
+            for scheme in self._SCHEME_MAP:
+                if scheme in ('purelib', 'platlib', 'mesonpy-libs'):
+                    continue
+                for destination, origin in self._wheel_files[scheme]:
+                    destination = pathlib.Path(self.data_dir, scheme, destination)
+                    whl.write(origin, destination.as_posix())
+
+        return wheel_file
 
 
 MesonArgsKeys = Literal['dist', 'setup', 'compile', 'install']
@@ -733,11 +779,29 @@ def _wheel_builder(self) -> _WheelBuilder:
             self._copy_files,
         )
 
+    @property
+    def source_dir(self) -> pathlib.Path:
+        return self._source_dir
+
+    @property
+    def working_dir(self) -> pathlib.Path:
+        return self._working_dir
+
+    @property
+    def build_dir(self) -> pathlib.Path:
+        return self._build_dir
+
+    def build_commands(self, install_dir: Optional[pathlib.Path] = None) -> Collection[Sequence[str]]:
+        return (
+            ('meson', 'compile', *self._meson_args['compile'],),
+            ('meson', 'install', '--destdir', os.fspath(install_dir or self._install_dir), *self._meson_args['install'],),
+        )
+
     @functools.lru_cache(maxsize=None)
     def build(self) -> None:
         """Trigger the Meson build."""
-        self._meson('compile', *self._meson_args['compile'],)
-        self._meson('install', '--destdir', os.fspath(self._install_dir), *self._meson_args['install'],)
+        for cmd in self.build_commands():
+            self._meson(*cmd[1:])
 
     @classmethod
     @contextlib.contextmanager
@@ -817,21 +881,46 @@ def version(self) -> str:
         assert isinstance(version, str)
         return version
 
-    @cached_property
-    def metadata(self) -> bytes:
+    @property
+    def top_level_modules(self) -> Collection[str]:
+        return {
+            os.path.dirname(self._copy_files[file])
+            for files in self._install_plan.values()
+            for file, details in files.items()
+            if details['destination'].startswith('{purelib}') or details['destination'].startswith('{platlib}')
+        }
+
+    @functools.lru_cache(maxsize=2)
+    def metadata(self, editable: bool = False) -> bytes:
         """Project metadata."""
         # the rest of the keys are only available when using PEP 621 metadata
         if not self.pep621:
-            return textwrap.dedent(f'''
+            data = textwrap.dedent(f'''
                 Metadata-Version: 2.1
                 Name: {self.name}
                 Version: {self.version}
-            ''').strip().encode()
+            ''').strip()
+            if editable:
+                data += f'\nRequires-Dist: mesonpy=={__version__}'
+            return data.encode()
+
         # re-import pyproject_metadata to raise ModuleNotFoundError if it is really missing
         import pyproject_metadata  # noqa: F401, F811
         assert self._metadata
+
+        metadata = dataclasses.replace(self._metadata)
+        # add extra dependency required for the editable hook
+        if editable:
+            from packaging.requirements import Requirement
+            metadata.dependencies.append(Requirement(f'mesonpy=={__version__}'))
+
+        core_metadata = metadata.as_rfc822()
+
         # use self.version as the version may be dynamic -- fetched from Meson
-        core_metadata = self._metadata.as_rfc822()
+        #
+        # we need to overwrite this field in the RFC822 field as
+        # pyproject_metadata removes 'version' from the dynamic fields when
+        # giving it a value via the dataclass
         core_metadata.headers['Version'] = [self.version]
         return bytes(core_metadata)
 
@@ -912,8 +1001,9 @@ def sdist(self, directory: Path) -> pathlib.Path:
             pkginfo_info = tarfile.TarInfo(f'{dist_name}/PKG-INFO')
             if mtime:
                 pkginfo_info.mtime = mtime
-            pkginfo_info.size = len(self.metadata)
-            tar.addfile(pkginfo_info, fileobj=io.BytesIO(self.metadata))
+            metadata = self.metadata()
+            pkginfo_info.size = len(metadata)
+            tar.addfile(pkginfo_info, fileobj=io.BytesIO(metadata))
 
         return sdist
 
@@ -925,6 +1015,9 @@ def wheel(self, directory: Path) -> pathlib.Path:  # noqa: F811
         shutil.move(os.fspath(wheel), final_wheel)
         return final_wheel
 
+    def editable(self, directory: Path) -> pathlib.Path:
+        return self._wheel_builder.build_editable(directory)
+
 
 @contextlib.contextmanager
 def _project(config_settings: Optional[Dict[Any, Any]]) -> Iterator[Project]:
@@ -1061,3 +1154,21 @@ def build_wheel(
     out = pathlib.Path(wheel_directory)
     with _project(config_settings) as project:
         return project.wheel(out).name
+
+
+def build_editable(
+    wheel_directory: str,
+    config_settings: Optional[Dict[Any, Any]] = None,
+    metadata_directory: Optional[str] = None,
+) -> str:
+    _setup_cli()
+
+    out = pathlib.Path(wheel_directory)
+    with _project(config_settings) as project:
+        return project.editable(out).name
+
+
+def get_requires_for_build_editable(
+    config_settings: Optional[Dict[str, str]] = None,
+) -> List[str]:
+    return get_requires_for_build_wheel()

mesonpy/_editable.py

@@ -0,0 +1,70 @@
+import functools
+import importlib.abc
+import os
+import subprocess
+import sys
+
+from types import ModuleType
+from typing import Optional, Union
+
+from mesonpy._compat import Collection, Sequence
+
+
+class MesonpyFinder(importlib.abc.MetaPathFinder):
+    """Custom loader that whose purpose is to detect when the import system is
+    trying to load our modules, and trigger a rebuild. After triggering a
+    rebuild, we return None in find_spec, letting the normal finders pick up the
+    modules.
+    """
+
+    def __init__(
+        self,
+        project_path: str,
+        top_level_modules: Collection[str],
+        rebuild_commands: Sequence[Sequence[str]],
+    ) -> None:
+        if not os.path.isabs(project_path):
+            raise ImportError('Project path must be absolute')
+        self._project_path = project_path
+        self._top_level_modules = top_level_modules
+        self._rebuild_commands = rebuild_commands
+
+    def __repr__(self) -> str:
+        return f'{self.__class__}({self._project_path})'
+
+    def __hash__(self) -> int:
+        return hash((self._project_path, self._top_level_modules, self._rebuild_commands))
+
+    @functools.lru_cache(maxsize=1)
+    def rebuild(self) -> None:
+        for command in self._rebuild_commands:
+            subprocess.check_call(command)
+
+    def find_spec(
+        self,
+        fullname: str,
+        path: Optional[Sequence[Union[str, bytes]]],
+        target: Optional[ModuleType] = None,
+    ) -> None:
+        # if it's one of our modules, trigger a rebuild
+        if fullname.split('.', maxsplit=1)[0] in self._top_level_modules:
+            self.rebuild()
+        # return none (meaning we "didn't find" the module) and let the normal
+        # finders find/import it
+        return None
+
+    @classmethod
+    def install(
+        cls,
+        project_path: str,
+        top_level_modules: Collection[str],
+        rebuild_commands: Sequence[Sequence[str]],
+    ) -> None:
+        finder = cls(project_path, top_level_modules, rebuild_commands)
+        if finder not in sys.meta_path:
+            # prepend our finder to sys.meta_path, so that it is queried before
+            # the normal finders, and can trigger a project rebuild
+            sys.meta_path.insert(0, finder)
+            # add the project path to sys.path, so that the normal finder can
+            # find our modules
+            sys.path.append(project_path)