refactor: RustProject methods with flags= instead of frozen attributes

Move test/clippy/fmt from frozen Step attributes to methods with
flags= parameter for per-call customization. Add hm.group() and
hm.pr() alias. Dogfood targets now self-contained.

Author: markovejnovic

.harmont/ci.py

@@ -2,8 +2,6 @@
 from __future__ import annotations
 
 import harmont as hm
-from harmont.py.uv import UvProject
-from harmont.rust import RustProject
 
 
 @hm.target()
@@ -20,13 +18,29 @@ def shared_base() -> hm.Step:
 
 
 @hm.target()
-def rust_project(shared_base: hm.Target[hm.Step]) -> RustProject:
-    return hm.rust.project(path=".", base=shared_base, test_flags=("--lib",))
+def rust_project(shared_base: hm.Target[hm.Step]) -> tuple[hm.Step, ...]:
+    project = hm.rust.project(path=".", base=shared_base)
+    return hm.group([
+        project.test(flags=("--lib",)),
+        project.clippy(),
+        project.fmt(),
+    ])
 
 
 @hm.target()
-def py_project(shared_base: hm.Target[hm.Step]) -> UvProject:
-    return hm.py.uv(path="dsls/harmont-py", base=shared_base)
+def py_project(shared_base: hm.Target[hm.Step]) -> tuple[hm.Step, ...]:
+    project = hm.py.uv(path="dsls/harmont-py", base=shared_base)
+    return hm.group([
+        project.lint(),
+        project.fmt(),
+        project.typecheck(paths="harmont"),
+        project.run(
+            "pytest -v"
+            " --deselect tests/test_gradle.py"
+            " --deselect tests/test_haskell.py",
+            label=":python: test",
+        ),
+    ])
 
 
 @hm.pipeline(
@@ -35,24 +49,11 @@ def py_project(shared_base: hm.Target[hm.Step]) -> UvProject:
     default_image="ubuntu:24.04",
     triggers=[
         hm.push(branch="main"),
-        hm.pull_request(branches="main"),
+        hm.pr(branches="main"),
     ],
 )
 def ci(
-    rust_project: hm.Target[RustProject],
-    py_project: hm.Target[UvProject],
-) -> tuple[hm.Step, ...]:
-    return (
-        rust_project.test,
-        rust_project.clippy,
-        rust_project.fmt,
-        py_project.lint(),
-        py_project.fmt(),
-        py_project.typecheck(paths="harmont"),
-        py_project.run(
-            "pytest -v"
-            " --deselect tests/test_gradle.py"
-            " --deselect tests/test_haskell.py",
-            label=":python: test",
-        ),
-    )
+    rust_project: hm.Target[tuple[hm.Step, ...]],
+    py_project: hm.Target[tuple[hm.Step, ...]],
+) -> list:
+    return [rust_project, py_project]

.harmont/ci.ts

@@ -19,17 +19,17 @@ const base = aptBase({
   ],
 });
 
-const rustProject = rust.project({ path: ".", base, testFlags: ["--lib"] });
+const rustProject = rust.project({ path: ".", base });
 const pyProject = py.uv({ path: "dsls/harmont-py", base });
 
 const pipelines: PipelineDefinition[] = [
   {
     slug: "ci",
     triggers: [push({ branch: "main" }), pullRequest({ branches: ["main"] })],
     pipeline: pipeline(
-      rustProject.test,
-      rustProject.clippy,
-      rustProject.fmt,
+      rustProject.test({ flags: ["--lib"] }),
+      rustProject.clippy(),
+      rustProject.fmt(),
       pyProject.lint(),
       pyProject.fmt(),
       pyProject.typecheck({ paths: "harmont" }),

dsls/harmont-py/harmont/__init__.py

@@ -59,7 +59,7 @@
 from .python import python
 from .ruby import ruby
 from .rust import RustProject, rust
-from .triggers import pull_request, push, schedule
+from .triggers import pull_request, pull_request as pr, push, schedule
 from .types import Pipeline
 from .zig import zig
 
@@ -128,6 +128,11 @@ def sh(
     )
 
 
+def group(steps: list[Step] | tuple[Step, ...]) -> tuple[Step, ...]:
+    """Combine steps into a group for use as a target return value."""
+    return tuple(steps)
+
+
 __all__ = [
     "BaseImage",
     "CacheCompose",
@@ -154,13 +159,15 @@ def sh(
     "forever",
     "go",
     "gradle",
+    "group",
     "haskell",
     "npm",
     "ocaml",
     "on_change",
     "perl",
     "pipeline",
     "pipeline_to_json",
+    "pr",
     "pull_request",
     "push",
     "py",

dsls/harmont-py/harmont/_unwrap.py

@@ -26,7 +26,7 @@ def _one(obj: object) -> tuple[Step, ...]:
     if isinstance(obj, Step):
         return (obj,)
     if isinstance(obj, RustProject):
-        return (obj.test, obj.clippy, obj.fmt)
+        return (obj.test(), obj.clippy(), obj.fmt())
     if isinstance(obj, HaskellPackage):
         return (obj.build(),)
     if isinstance(obj, RustToolchain):

dsls/harmont-py/harmont/rust.py

@@ -90,9 +90,30 @@ class RustProject:
 
     toolchain: RustToolchain
     warmup: Step
-    test: Step
-    clippy: Step
-    fmt: Step
+
+    def test(self, *, flags: tuple[str, ...] = (), **kw: Any) -> Step:
+        extra = (" " + " ".join(flags)) if flags else ""
+        return self.warmup.sh(
+            self.toolchain._wrap(f"cargo test --workspace --locked{extra}"),
+            label=kw.pop("label", ":rust: test"),
+            **kw,
+        )
+
+    def clippy(self, *, flags: tuple[str, ...] = (), **kw: Any) -> Step:
+        extra = (" " + " ".join(flags)) if flags else ""
+        return self.warmup.sh(
+            self.toolchain._wrap(
+                f"cargo clippy --workspace --tests --locked{extra} -- -D warnings"
+            ),
+            label=kw.pop("label", ":rust: clippy"),
+            **kw,
+        )
+
+    def fmt(self, *, flags: tuple[str, ...] = (), **kw: Any) -> Step:
+        extra = (" " + " ".join(flags)) if flags else ""
+        return self.toolchain._emit(
+            f"cargo fmt --check{extra}", ":rust: fmt", **kw
+        )
 
 
 def _make_rust(
@@ -130,9 +151,6 @@ def _make_rust_project(
     components: tuple[str, ...] = ("clippy", "rustfmt"),
     base: Step | None = None,
     cache: CachePolicy | None = None,
-    test_flags: tuple[str, ...] = (),
-    clippy_flags: tuple[str, ...] = (),
-    fmt_flags: tuple[str, ...] = (),
 ) -> RustProject:
     tc = _make_rust(
         path=path,
@@ -151,30 +169,7 @@ def _make_rust_project(
         cache=warmup_cache,
     )
 
-    test_extra = (" " + " ".join(test_flags)) if test_flags else ""
-    test_step = warm.sh(
-        tc._wrap(f"cargo test --workspace --locked{test_extra}"),
-        label=":rust: test",
-    )
-
-    clippy_extra = (" " + " ".join(clippy_flags)) if clippy_flags else ""
-    clippy_step = warm.sh(
-        tc._wrap(
-            f"cargo clippy --workspace --tests --locked{clippy_extra} -- -D warnings"
-        ),
-        label=":rust: clippy",
-    )
-
-    fmt_extra = (" " + " ".join(fmt_flags)) if fmt_flags else ""
-    fmt_step = tc._emit(f"cargo fmt --check{fmt_extra}", ":rust: fmt")
-
-    return RustProject(
-        toolchain=tc,
-        warmup=warm,
-        test=test_step,
-        clippy=clippy_step,
-        fmt=fmt_step,
-    )
+    return RustProject(toolchain=tc, warmup=warm)
 
 
 class _RustEntry:
@@ -206,9 +201,6 @@ def project(
         components: tuple[str, ...] = ("clippy", "rustfmt"),
         base: Step | None = None,
         cache: CachePolicy | None = None,
-        test_flags: tuple[str, ...] = (),
-        clippy_flags: tuple[str, ...] = (),
-        fmt_flags: tuple[str, ...] = (),
     ) -> RustProject:
         return _make_rust_project(
             path=path,
@@ -217,9 +209,6 @@ def project(
             components=components,
             base=base,
             cache=cache,
-            test_flags=test_flags,
-            clippy_flags=clippy_flags,
-            fmt_flags=fmt_flags,
         )
 
 

dsls/harmont-py/tests/test_rust.py

@@ -164,12 +164,12 @@ def test_warmup_in_pipeline(self):
 
 
 class TestRustProject:
-    def test_project_has_all_steps(self):
+    def test_project_has_all_methods(self):
         proj = hm.rust.project(path="cli")
         assert proj.warmup.cmd is not None
-        assert proj.test.cmd is not None
-        assert proj.clippy.cmd is not None
-        assert proj.fmt.cmd is not None
+        assert proj.test().cmd is not None
+        assert proj.clippy().cmd is not None
+        assert proj.fmt().cmd is not None
 
     def test_warmup_implicit_cache_on_change(self):
         proj = hm.rust.project(path="cli")
@@ -186,39 +186,39 @@ def test_warmup_cache_override(self):
 
     def test_test_command(self):
         proj = hm.rust.project(path="cli")
-        assert "cargo test --workspace --locked" in proj.test.cmd
+        assert "cargo test --workspace --locked" in proj.test().cmd
 
     def test_test_flags(self):
-        proj = hm.rust.project(path=".", test_flags=("--lib", "--no-fail-fast"))
-        assert "cargo test --workspace --locked --lib --no-fail-fast" in proj.test.cmd
+        proj = hm.rust.project(path=".")
+        assert "cargo test --workspace --locked --lib --no-fail-fast" in proj.test(flags=("--lib", "--no-fail-fast")).cmd
 
     def test_clippy_command(self):
         proj = hm.rust.project(path="cli")
-        assert "cargo clippy --workspace --tests --locked -- -D warnings" in proj.clippy.cmd
+        assert "cargo clippy --workspace --tests --locked -- -D warnings" in proj.clippy().cmd
 
     def test_clippy_flags(self):
-        proj = hm.rust.project(path=".", clippy_flags=("--fix",))
-        assert "cargo clippy --workspace --tests --locked --fix -- -D warnings" in proj.clippy.cmd
+        proj = hm.rust.project(path=".")
+        assert "cargo clippy --workspace --tests --locked --fix -- -D warnings" in proj.clippy(flags=("--fix",)).cmd
 
     def test_fmt_command(self):
         proj = hm.rust.project(path="cli")
-        assert "cargo fmt --check" in proj.fmt.cmd
+        assert "cargo fmt --check" in proj.fmt().cmd
 
     def test_fmt_flags(self):
-        proj = hm.rust.project(path=".", fmt_flags=("--all",))
-        assert "cargo fmt --check --all" in proj.fmt.cmd
+        proj = hm.rust.project(path=".")
+        assert "cargo fmt --check --all" in proj.fmt(flags=("--all",)).cmd
 
     def test_test_chains_off_warmup(self):
         proj = hm.rust.project(path=".")
-        assert proj.test.parent is proj.warmup
+        assert proj.test().parent is proj.warmup
 
     def test_clippy_chains_off_warmup(self):
         proj = hm.rust.project(path=".")
-        assert proj.clippy.parent is proj.warmup
+        assert proj.clippy().parent is proj.warmup
 
     def test_fmt_chains_off_install(self):
         proj = hm.rust.project(path=".")
-        assert proj.fmt.parent is proj.toolchain.installed
+        assert proj.fmt().parent is proj.toolchain.installed
 
     def test_toolchain_escape_hatch(self):
         proj = hm.rust.project(path="cli")
@@ -228,21 +228,21 @@ def test_toolchain_escape_hatch(self):
     def test_with_base_skips_apt(self):
         base = hm.scratch().sh("custom base", label="base")
         proj = hm.rust.project(path="cli", base=base)
-        p = hm.pipeline(proj.test, proj.clippy, proj.fmt, default_image="ubuntu:24.04")
+        p = hm.pipeline(proj.test(), proj.clippy(), proj.fmt(), default_image="ubuntu:24.04")
         cmds = _cmds(p)
         assert not any("apt-get install" in c for c in cmds)
         assert any("custom base" in c for c in cmds)
 
     def test_labels(self):
         proj = hm.rust.project(path=".")
         assert proj.warmup.label == ":rust: warmup"
-        assert proj.test.label == ":rust: test"
-        assert proj.clippy.label == ":rust: clippy"
-        assert proj.fmt.label == ":rust: fmt"
+        assert proj.test().label == ":rust: test"
+        assert proj.clippy().label == ":rust: clippy"
+        assert proj.fmt().label == ":rust: fmt"
 
     def test_pipeline_ir(self):
         proj = hm.rust.project(path="cli")
-        p = hm.pipeline(proj.test, proj.clippy, proj.fmt, default_image="ubuntu:24.04")
+        p = hm.pipeline(proj.test(), proj.clippy(), proj.fmt(), default_image="ubuntu:24.04")
         cmds = _cmds(p)
         assert any("cargo build --workspace --tests --locked" in c for c in cmds)
         assert any("cargo test --workspace --locked" in c for c in cmds)
@@ -253,6 +253,6 @@ def test_pipeline_ir(self):
 
     def test_version_forwarded(self):
         proj = hm.rust.project(path=".", version="1.81.0")
-        p = hm.pipeline(proj.test)
+        p = hm.pipeline(proj.test())
         rustup = _step_by_substring(p, "sh.rustup.rs")
         assert "--default-toolchain 1.81.0" in rustup["cmd"]