test: add default entries detection tests

project_manager/__init__.py

@@ -0,0 +1 @@
+from .logging import *

project_manager/manager.py

@@ -13,14 +13,13 @@ logger = logging.getLogger("project")
 
 
 class ProjectManager:
-    DEFAULT_PRESET = Path(__file__).parent / "default_preset.toml"
-    DEFAULT_IGNORE = ["node_modules", ".venv", ".git"]
+    DEFAULT_IGNORE = ["node_modules", ".venv", ".git", "tests"]
     _logger = logger
 
     def __init__(self, basepath: Path):
         self._basepaht = basepath
         self._resolver = EntryResolver(
-            PresetEntryDetector(self.DEFAULT_PRESET),
+            PresetEntryDetector(),
             self.DEFAULT_IGNORE,
         )
 

project_manager/pipe/core.py

@@ -67,6 +67,8 @@ class PipeRunner:
         result = None
         for pipe in pipes:
             result = pipe.apply(result, self._basepath)
+            if result is None:
+                break
         return result
 
     def resolve_value(self, pipeline: str) -> Any:

project_manager/preset/default/python.toml

@@ -6,7 +6,11 @@ conditions = [
     "file(pyproject.toml) | get(build-system.build-backend) | equal(poetry.core.masonry.api)",
 ]
 variables.python_version = "file(pyproject.toml) | get(tool.poetry.dependencies.python) | search((\\d.\\d))"
-commands = ["poetry env use {python_version}", "poetry install"]
+commands = [
+    "poetry env use system",
+    "poetry env use {python_version}",
+    "poetry install",
+]
 
 [presets.python.tasks.build.poetry]
 conditions = [
@@ -17,7 +21,7 @@ commands = ["poetry build"]
 [presets.python.tasks.publish.poetry]
 conditions = [
     "file(pyproject.toml) | get(build-system.build-backend) | equal(poetry.core.masonry.api)",
-    "file(poetry.toml)",
+    "file(poetry.toml) | get(repositories)",
 ]
 variables.python_repository = "file(poetry.toml) | get(repositories) | key(0)"
 commands = ["poetry publish -r {python_repository}"]

project_manager/preset/entry.py

@@ -5,7 +5,7 @@ from typing import Optional
 
 from ..entry import Entry, EntryDetector
 from ..pipe.core import PipeParser, PipeRunner
-from .resolve import PresetResolver
+from .resolve import PresetResolver, PresetResolverConfig
 
 __all__ = ("PresetEntryDetector",)
 
@@ -13,11 +13,12 @@ __all__ = ("PresetEntryDetector",)
 class PresetEntryDetector(EntryDetector):
     _PIPE_PARSER = PipeParser()
 
-    def __init__(self, filename: Path):
+    def __init__(self, preset_resolver_config: Optional[PresetResolverConfig] = None):
         self._pipeparser = PipeParser()
+        self._preset_resolver_config = preset_resolver_config
 
     def detect_entry(self, basepath: Path) -> Optional["Entry"]:
-        preset = PresetResolver(basepath).resolve_preset()
+        preset = PresetResolver(basepath, self._preset_resolver_config).resolve_preset()
         piperunner = PipeRunner(basepath)
         tasks = defaultdict(list)
         for preset_name, preset in preset.presets.items():
@@ -26,14 +27,16 @@ class PresetEntryDetector(EntryDetector):
             for task_name, task_pack in preset.tasks.items():
                 for task_item_name, task in task_pack.items():
                     if piperunner.check_conditions(task.conditions):
-                        variables = (
-                            {
-                                k: piperunner.resolve_value(v)
-                                for k, v in task.variables.items()
-                            }
-                            if task.variables
-                            else {}
-                        )
+                        variables = {
+                            "entry_path": basepath,
+                        }
+                        if task.variables:
+                            variables.update(
+                                {
+                                    k: piperunner.resolve_value(v)
+                                    for k, v in task.variables.items()
+                                }
+                            )
                         tasks[task_name] += [
                             command.format(**variables) for command in task.commands
                         ]

project_manager/preset/resolve.py

@@ -1,35 +1,49 @@
-__all__ = ("PresetResolver",)
-
-
+from dataclasses import dataclass
 from pathlib import Path
-from typing import Dict, Iterable
+from typing import Dict, Iterable, Optional
 
 import tomli
 
 from ..util import merge_dicts
 from .model import Preset
 
+__all__ = (
+    "PresetResolverConfig",
+    "PresetResolver",
+)
+
+
+@dataclass
+class PresetResolverConfig:
+    deafult: bool = True
+    user: bool = True
+    project: bool = True
+
 
 class PresetResolver:
     _source_cache: Dict[Path, dict] = {}
 
-    def __init__(self, basepath: Path):
+    def __init__(self, basepath: Path, config: Optional[PresetResolverConfig] = None):
         self._basepath = basepath
+        self._config = config or PresetResolverConfig()
 
     def iter_sources(self) -> Iterable[Path]:
-        for filepath in (Path(__file__).parent / "default").iterdir():
-            yield filepath
-        user_preset = Path.home() / ".preset.toml"
-        if user_preset.exists():
-            yield user_preset
-        projectpath = self._basepath
-        while projectpath.exists():
-            project_preset = projectpath / ".preset.toml"
-            if project_preset.exists():
-                yield project_preset
-            if projectpath.parent == projectpath:
-                break
-            projectpath = projectpath.parent
+        if self._config.deafult:
+            for filepath in (Path(__file__).parent / "default").iterdir():
+                yield filepath
+        if self._config.user:
+            user_preset = Path.home() / ".preset.toml"
+            if user_preset.exists():
+                yield user_preset
+        if self._config.project:
+            projectpath = self._basepath
+            while projectpath.exists():
+                project_preset = projectpath / ".preset.toml"
+                if project_preset.exists():
+                    yield project_preset
+                if projectpath.parent == projectpath:
+                    break
+                projectpath = projectpath.parent
 
     def resolve_preset(self) -> Preset:
         result_preset_data = {}