repoactive 0.2.5.dev1__tar.gz → 0.2.6__tar.gz

{repoactive-0.2.5.dev1 → repoactive-0.2.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: repoactive
-Version: 0.2.5.dev1
+Version: 0.2.6
 Summary: Script-driven code changes with automated merge requests
 License-Expression: GPL-3.0-or-later
 License-File: LICENSE

{repoactive-0.2.5.dev1 → repoactive-0.2.6}/pyproject.toml

@@ -10,7 +10,7 @@ only-include = ["src"]
 
 [project]
 name = "repoactive"
-version = "0.2.5.dev1"
+version = "0.2.6"
 description = "Script-driven code changes with automated merge requests"
 readme = "README.md"
 requires-python = ">=3.11"

repoactive-0.2.6/src/repoactive/boxquote.py

@@ -0,0 +1,32 @@
+"""Render and strip boxquote.el-style boxes used to embed command output in messages."""
+
+import re
+
+# A boxquote block: a ``,----`` opening line through its closing ``` `---- ``` line.
+# DOTALL lets ``.*?`` span the body lines; MULTILINE anchors both delimiters to a
+# line of their own. Non-greedy so each block stops at its own closing line.
+_BOXQUOTE_BLOCK = re.compile(r"^,----.*?^`----[ \t]*$", re.MULTILINE | re.DOTALL)
+
+
+def boxquote(msg: str, title: str = "") -> str:
+    """Render ``msg`` inside a boxquote.el-style box.
+
+    The first line is ``,----[ title ]`` (or just ``,----`` when ``title`` is
+    empty), each line of ``msg`` is prefixed with ``| ``, and the box closes
+    with ``` `---- ```.
+    """
+    top = f",----[ {title} ]" if title else ",----"
+    body = "\n".join(f"| {line}" for line in msg.splitlines())
+    return f"{top}\n{body}\n`----"
+
+
+def strip_boxquotes(text: str) -> str:
+    """Remove every boxquote block (see :func:`boxquote`) from ``text``.
+
+    A block runs from a ``,----`` opening line to its closing ``` `---- ``` line;
+    the surrounding text is kept. Blank lines exposed by a removed block are
+    collapsed so paragraphs stay separated by a single blank line, and leading
+    and trailing blank lines are trimmed.
+    """
+    without = _BOXQUOTE_BLOCK.sub("", text)
+    return re.sub(r"\n{3,}", "\n\n", without).strip("\n")

{repoactive-0.2.5.dev1 → repoactive-0.2.6}/src/repoactive/cli.py

@@ -42,10 +42,9 @@ from repoactive.platforms import (
 from repoactive.platforms.base import PlatformError
 from repoactive.runner import (
     RunMode,
-    UnknownJobsError,
-    UnknownTagsError,
     run_all,
 )
+from repoactive.selection import UnknownJobsError, UnknownTagsError
 from repoactive.settings import SettingsError, load_settings
 from repoactive.ui import err_console, print_undo_hint
 
@@ -241,8 +240,8 @@ def run(  # noqa: PLR0913
             config=cfg,
             repo_path=repo,
             platform=platform,
-            requested_names=jobs or None,
-            requested_tags=tags or None,
+            requested_names=frozenset(jobs or []),
+            requested_tags=frozenset(tags or []),
             mode=mode,
         )
     except RunLockHeldError as e:
@@ -361,14 +360,14 @@ def dump_schema(
 def _print_commit_table(commits: list[JobCommit]) -> None:
     """Print ``commits`` as columns padded to their widest value."""
     names_column = [",".join(sorted(c.job_names)) for c in commits]
-    id_width = max(len(c.commit_id) for c in commits)
+    commit_width = max(len(c.commit_id) for c in commits)
     change_width = max(len(c.change_id) for c in commits)
-    name_width = max(len(names) for names in names_column)
+    names_width = max(len(names) for names in names_column)
     age_width = max(len(c.relative_age) for c in commits)
     for c, names in zip(commits, names_column, strict=True):
         typer.echo(
-            f"{c.commit_id:<{id_width}}  {c.change_id:<{change_width}}  "
-            f"{names:<{name_width}}  {c.relative_age:<{age_width}}  {c.subject}"
+            f"{c.commit_id:<{commit_width}}  {c.change_id:<{change_width}}  "
+            f"{names:<{names_width}}  {c.relative_age:<{age_width}}  {c.subject}"
         )
 
 

{repoactive-0.2.5.dev1 → repoactive-0.2.6}/src/repoactive/config.py

@@ -278,8 +278,18 @@ def _validate_duration(value: str) -> str:
     return value
 
 
+def _validate_single_line(value: str, info: ValidationInfo) -> str:
+    if "\n" in value:
+        assert info.field_name is not None
+        raise NewlineInTitleError(info.field_name, value)
+    return value
+
+
 _BranchPrefix = Annotated[str, AfterValidator(_validate_branch_prefix)]
 _Duration = Annotated[str, AfterValidator(_validate_duration)]
+# Titles and title prefixes end up in commit subjects and MR titles, which are
+# single-line by nature.
+_SingleLine = Annotated[str, AfterValidator(_validate_single_line)]
 # json_schema_input_type keeps booleans valid in the published JSON schema.
 _CreateMR = Annotated[
     CreateMR, BeforeValidator(_coerce_create_mr, json_schema_input_type=bool | CreateMR)
@@ -290,22 +300,14 @@ class JobDefaults(BaseModel):
     model_config = ConfigDict(extra="forbid")
 
     branch_prefix: _BranchPrefix = "repoactive/"
-    mr_title_prefix: str = "[repoactive] "
-    commit_title_prefix: str = "[repoactive] "
+    mr_title_prefix: _SingleLine = "[repoactive] "
+    commit_title_prefix: _SingleLine = "[repoactive] "
     labels: list[str] = Field(default_factory=list)
     base_branch: str | None = None
     cooldown_period: _Duration | None = None
     timeout: _Duration | None = "2m"
     auto_merge: bool = False
 
-    @field_validator("mr_title_prefix", "commit_title_prefix")
-    @classmethod
-    def _check_no_newline(cls, value: str, info: ValidationInfo) -> str:
-        if "\n" in value:
-            assert info.field_name is not None
-            raise NewlineInTitleError(info.field_name, value)
-        return value
-
 
 # Fields Job.resolve fills in from JobDefaults when the job does not set them
 # itself. labels is absent on purpose: it is merged, not replaced (see resolve).
@@ -325,7 +327,7 @@ class Job(BaseModel):
 
     name: str
     command: str
-    title: str
+    title: _SingleLine
     description: str | None = None
     base_branch: str | None = None
     draft: bool = False
@@ -352,8 +354,8 @@ class Job(BaseModel):
 
     # the following fields will be resolved from the defaults
     branch_prefix: _BranchPrefix | None = None
-    mr_title_prefix: str | None = None
-    commit_title_prefix: str | None = None
+    mr_title_prefix: _SingleLine | None = None
+    commit_title_prefix: _SingleLine | None = None
     labels: list[str] = Field(default_factory=list)
     cooldown_period: _Duration | None = None
     timeout: _Duration | None = None
@@ -366,14 +368,6 @@ class Job(BaseModel):
             raise InvalidJobNameError(value)
         return value
 
-    @field_validator("title", "commit_title_prefix")
-    @classmethod
-    def _check_no_newline(cls, value: str, info: ValidationInfo) -> str:
-        if "\n" in value:
-            assert info.field_name is not None
-            raise NewlineInTitleError(info.field_name, value)
-        return value
-
     @field_validator("tags")
     @classmethod
     def _check_tags(cls, value: list[str]) -> list[str]:

{repoactive-0.2.5.dev1 → repoactive-0.2.6}/src/repoactive/jj.py

@@ -219,9 +219,6 @@ class JJ:
     def new(self, *parents: str) -> None:
         self._run("new", *parents)
 
-    def edit(self, revision: str) -> None:
-        self._run("edit", revision)
-
     def restore(self, *, source_rev: str, destination_rev: str) -> None:
         self._run("restore", "--from", source_rev, "--into", destination_rev)
 
@@ -354,27 +351,8 @@ class JJ:
                 )
         return result
 
-    def pending_job_names(self, revset: str | None = None) -> set[str]:
-        """Job names that appear on unmerged commits reachable via ``revset``.
-
-        Without ``revset``: scans all commits not yet landed in trunk —
-        used by the default run to refresh stale branches (ADR 0003). A commit
-        may carry more than one trailer (a generated job records both its own
-        name and the generator's, see ADR 0004), so comma-joined values are
-        split; job names never contain commas.
-
-        With ``revset``: scans all descendants of ``revset`` that are not
-        in trunk — used by successor expansion to pull in jobs whose commits
-        sit anywhere in the stack above a selected job's bookmark (ADR 0012).
-        Uses ``present()`` semantics implicitly via the caller-supplied revset,
-        so non-existent bookmarks are silently skipped.
-        """
-        if revset is not None:
-            if not revset:
-                return set()
-            target = f"descendants({revset}) & ~({revset}) & ~(::trunk())"
-        else:
-            target = "~(::trunk())"
+    def job_names_in_revset(self, revset: str) -> set[str]:
+        """Job names that appear in revset."""
         template = f"""
         if(trailers.contains_key("{JOB_TRAILER_KEY}"),
            trailers.filter(|t| t.key() == "{JOB_TRAILER_KEY}").map(|t| t.value()).join(",")
@@ -382,7 +360,7 @@ class JJ:
            ""
         )
         """
-        output = self._run("log", "--no-graph", "-r", target, "-T", template)
+        output = self._run("log", "--no-graph", "-r", revset, "-T", template)
         return {
             name.strip()
             for line in output.splitlines()
@@ -421,8 +399,8 @@ class JJ:
         lines = [line.strip() for line in output.splitlines() if line.strip()]
         if not lines:
             return None
-        # jj log returns newest-first; take the first line.
-        return datetime.fromisoformat(lines[0]).replace(tzinfo=UTC)
+        # ISO-8601 strings are lexicographically ordered, so max() gives the newest.
+        return datetime.fromisoformat(max(lines)).replace(tzinfo=UTC)
 
     def git_push_bookmarks(self, *bookmarks: str) -> None:
         """Push bookmarks to the remote.

{repoactive-0.2.5.dev1 → repoactive-0.2.6}/src/repoactive/platforms/github.py

@@ -60,5 +60,8 @@ class GitHubPlatform(Platform):
             if params.labels:
                 pr.set_labels(*params.labels)
         if params.auto_merge:
-            pr.enable_automerge()
+            try:
+                pr.enable_automerge()
+            except GithubException as e:
+                print(f"  warning: could not enable auto-merge ({e})")
         return pr.html_url

repoactive-0.2.6/src/repoactive/platforms/gitlab.py

@@ -0,0 +1,105 @@
+"""GitLab platform implementation using python-gitlab."""
+
+import time
+
+import gitlab
+from gitlab.exceptions import GitlabError, GitlabMRClosedError
+from gitlab.v4.objects import ProjectMergeRequest
+
+from repoactive.platforms.base import MRParams, Platform, PlatformError
+
+_DRAFT_PREFIX = "Draft: "
+
+# detailed_merge_status / merge_status values that mean GitLab's async
+# mergeability check hasn't finished yet. Setting auto-merge while the check is
+# pending returns 422 "Branch cannot be merged".
+_MERGE_CHECK_PENDING = frozenset({"unchecked", "checking", "preparing"})
+
+# A freshly created MR is not immediately ready for auto-merge: GitLab runs the
+# mergeability check and creates the MR pipeline in the background. Poll for
+# that to settle, bounded by this timeout; the next run re-attempts if it never
+# does.
+_AUTO_MERGE_TIMEOUT = 60.0
+_AUTO_MERGE_POLL_INTERVAL = 3.0
+
+
+def _mr_title(title: str, *, draft: bool) -> str:
+    return f"{_DRAFT_PREFIX}{title}" if draft else title
+
+
+def _ready_for_auto_merge(mr: ProjectMergeRequest) -> bool:
+    """Report whether GitLab can accept merge_when_pipeline_succeeds for ``mr``.
+
+    Two conditions must hold. The mergeability check must be done: setting the
+    flag while detailed_merge_status is still ``checking``/``unchecked``/
+    ``preparing`` returns 422 "Branch cannot be merged". And a pipeline must
+    exist: with none, merge_when_pipeline_succeeds has nothing to wait for and
+    GitLab merges immediately, defeating the point of auto-merge.
+    """
+    status = getattr(mr, "detailed_merge_status", None) or getattr(mr, "merge_status", None)
+    if status in _MERGE_CHECK_PENDING:
+        return False
+    return getattr(mr, "head_pipeline", None) is not None
+
+
+class GitLabPlatform(Platform):
+    def __init__(self, *, url: str | None, token: str, repo: str) -> None:
+        self._gl = gitlab.Gitlab(url or "https://gitlab.com", private_token=token)
+        try:
+            self._project = self._gl.projects.get(repo)
+        except GitlabError as e:
+            raise PlatformError("GitLab", repo, e) from e
+
+    def default_branch(self) -> str:
+        return self._project.default_branch
+
+    def ensure_mr(self, params: MRParams) -> str:
+        title = _mr_title(params.title, draft=params.draft)
+        existing = self._project.mergerequests.list(
+            source_branch=params.source_branch,
+            state="opened",
+            iterator=False,
+        )
+        if existing:
+            mr = existing[0]
+            mr.title = title
+            mr.description = params.description
+            mr.labels = params.labels
+            # Retarget in case the job's base_branch changed since the MR was
+            # created.
+            mr.target_branch = params.target_branch
+            mr.save()
+        else:
+            mr = self._project.mergerequests.create(
+                {
+                    "source_branch": params.source_branch,
+                    "target_branch": params.target_branch,
+                    "title": title,
+                    "description": params.description,
+                    "labels": params.labels,
+                }
+            )
+        web_url = mr.web_url
+        if params.auto_merge:
+            self._enable_auto_merge(mr)
+        return web_url
+
+    def _enable_auto_merge(self, mr: ProjectMergeRequest) -> None:
+        """Set merge_when_pipeline_succeeds once the MR is ready, else warn.
+
+        Re-fetches the MR (the list/create payloads omit head_pipeline) and
+        polls until it is ready for auto-merge or the timeout passes. A repo
+        with no CI never grows a pipeline; there the poll times out and the
+        final call merges immediately, the best available behavior.
+        """
+        iid = mr.iid
+        deadline = time.monotonic() + _AUTO_MERGE_TIMEOUT
+        while True:
+            mr = self._project.mergerequests.get(iid)
+            if _ready_for_auto_merge(mr) or time.monotonic() >= deadline:
+                break
+            time.sleep(_AUTO_MERGE_POLL_INTERVAL)
+        try:
+            mr.merge(merge_when_pipeline_succeeds=True)
+        except GitlabMRClosedError as e:
+            print(f"  warning: could not enable auto-merge ({e})")