splent-cli 1.51.0__tar.gz → 1.53.0__tar.gz

{splent_cli-1.51.0/src/splent_cli.egg-info → splent_cli-1.53.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: splent_cli
-Version: 1.51.0
+Version: 1.53.0
 Summary: SPLENT-CLI is a CLI to be able to work on your development more easily.
 Author-email: DiversoLab <diversolab@us.es>
 License-Expression: LGPL-3.0-or-later

{splent_cli-1.51.0 → splent_cli-1.53.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "splent_cli"
-version = "1.51.0"
+version = "1.53.0"
 description = "SPLENT-CLI is a CLI to be able to work on your development more easily."
 readme = "README.md"
 requires-python = ">=3.13"

{splent_cli-1.51.0 → splent_cli-1.53.0}/src/splent_cli/commands/product/product_release.py

@@ -6,6 +6,7 @@ import contextlib
 import json
 import os
 import subprocess
+import sys
 import tempfile
 
 import click
@@ -28,6 +29,7 @@ from splent_cli.services import (
     image_registry,
     release,
     release_gate,
+    release_workspace,
     source_mirror,
 )
 from splent_cli.utils.proc import run, require_docker
@@ -40,19 +42,9 @@ def _guard_all_features_pinned(product_path: str):
     features_prod declare, so an editable entry in any of them makes the
     release irreproducible, not only one in the base list.
     """
-    from splent_cli.utils.feature_utils import (
-        FEATURE_LIST_KEYS,
-        load_product_pyproject,
-        read_feature_list,
-    )
+    from splent_cli.utils.feature_utils import load_product_pyproject
 
-    data = load_product_pyproject(product_path)
-    editable = [
-        (key, entry)
-        for key in FEATURE_LIST_KEYS
-        for entry in read_feature_list(data, key)
-        if "@" not in entry
-    ]
+    editable = release_workspace.editable_features(load_product_pyproject(product_path))
     if not editable:
         return
 
@@ -427,6 +419,13 @@ def product_release(
         click.secho(f"  error: pyproject.toml not found in {product}", fg="red")
         raise SystemExit(1)
 
+    if release_workspace.in_development_mode(product_path):
+        raise SystemExit(
+            release_workspace.run_from_head(
+                product, product_path, str(context.workspace()), sys.argv[1:]
+            )
+        )
+
     _guard_all_features_pinned(product_path)
     _guard_deployable(str(context.workspace()), product, product_path)
     mirror = None if no_mirror else _declared_source_mirror(product_path)

{splent_cli-1.51.0 → splent_cli-1.53.0}/src/splent_cli/commands/release/release_resume.py

@@ -33,11 +33,18 @@ import contextlib
 import os
 import shutil
 import subprocess
+import sys
 import tempfile
 
 import click
 
-from splent_cli.services import context, release, release_gate, source_mirror
+from splent_cli.services import (
+    context,
+    release,
+    release_gate,
+    release_workspace,
+    source_mirror,
+)
 from splent_cli.utils import forge
 from splent_cli.utils.git_url import _non_interactive_env
 
@@ -322,6 +329,13 @@ def release_resume(target, assume_yes, no_pypi, no_forge, no_github, no_docker,
     no_forge = release.no_forge_requested(no_forge, no_github)
     workspace = str(context.workspace())
     path, label, kind = resolve_target(target, workspace)
+    if kind == "product" and release_workspace.in_development_mode(path):
+        raise SystemExit(
+            release_workspace.run_from_head(
+                os.path.basename(path), path, workspace, sys.argv[1:]
+            )
+        )
+
     # What the hints this run prints tell the operator to run next. A withheld
     # image stays withheld.
     hint_target = f"{target} --no-docker" if no_docker else target

splent_cli-1.53.0/src/splent_cli/services/release_workspace.py

@@ -0,0 +1,223 @@
+"""Releasing what HEAD holds while the checkout is in development mode.
+
+A product under development lists its features without a version in
+pyproject.toml, uncommitted, so the app mounts their working copies. HEAD keeps
+them pinned. Such a checkout cannot release as it is, and it should not have to
+change either: a release is what is committed.
+
+So product:release and release:resume run from a temporary workspace of their
+own, a worktree of HEAD next to the cache and the product line's model, and the
+checkout moves forward afterwards with its pyproject.toml as it was, bar what
+the release changed in it.
+"""
+
+from __future__ import annotations
+
+import glob
+import os
+import shutil
+import subprocess
+import sys
+import tempfile
+import tomllib
+
+import click
+
+from splent_cli.utils.feature_utils import (
+    FEATURE_LIST_KEYS,
+    load_product_pyproject,
+    read_feature_list,
+)
+
+PYPROJECT = "pyproject.toml"
+
+
+def editable_features(data: dict) -> list[tuple[str, str]]:
+    """``(list, entry)`` of every feature of a pyproject with no version pinned.
+
+    Every list counts. A release runs whatever features, features_dev and
+    features_prod declare.
+    """
+    return [
+        (key, entry)
+        for key in FEATURE_LIST_KEYS
+        for entry in read_feature_list(data, key)
+        if "@" not in entry
+    ]
+
+
+def _git(path: str, *args: str) -> subprocess.CompletedProcess:
+    return subprocess.run(["git", *args], cwd=path, capture_output=True, text=True)
+
+
+def in_development_mode(product_path: str) -> bool:
+    """Whether the checkout has editable features and HEAD has none."""
+    if not editable_features(load_product_pyproject(product_path)):
+        return False
+    head = _git(product_path, "show", f"HEAD:{PYPROJECT}")
+    if head.returncode != 0:
+        return False
+    try:
+        return not editable_features(tomllib.loads(head.stdout))
+    except tomllib.TOMLDecodeError:
+        return False
+
+
+def _only_in_checkout(work: dict, head: dict, path: str = "") -> list[str]:
+    """What the checkout's pyproject.toml says that HEAD does not, pins aside."""
+    found = []
+    for key, value in work.items():
+        where = f"{path}.{key}" if path else key
+        if path == "tool.splent" and key in FEATURE_LIST_KEYS:
+            continue
+        if key not in head:
+            found.append(where)
+        elif isinstance(value, dict) and isinstance(head[key], dict):
+            found.extend(_only_in_checkout(value, head[key], where))
+        elif value != head[key]:
+            found.append(where)
+    return found
+
+
+def settings_left_out(product_path: str) -> list[str]:
+    """The settings of the checkout's pyproject.toml this release will not carry.
+
+    The feature lists are what development mode changes on purpose. Anything
+    else there holds in development and not in production, without a word:
+    that is how a product kept serving a page its pyproject.toml turned off.
+    """
+    head = _git(product_path, "show", f"HEAD:{PYPROJECT}")
+    try:
+        return _only_in_checkout(
+            load_product_pyproject(product_path), tomllib.loads(head.stdout)
+        )
+    except tomllib.TOMLDecodeError:
+        return []
+
+
+def _splent(args: list[str], env: dict) -> int:
+    """Run the CLI in the temporary workspace, in this terminal."""
+    return subprocess.run(
+        [sys.executable, "-m", "splent_cli", *args], env=env
+    ).returncode
+
+
+def _merged_pyproject(path: str, ours: str, base: str, theirs: str) -> str | None:
+    """Three-way merge of the checkout's pyproject.toml, None on a conflict."""
+    with tempfile.TemporaryDirectory(prefix="splent_pyproject_") as tmp:
+        names = []
+        for name, content in (("ours", ours), ("base", base), ("theirs", theirs)):
+            names.append(os.path.join(tmp, name))
+            with open(names[-1], "w", encoding="utf-8") as f:
+                f.write(content)
+        merged = _git(path, "merge-file", "-p", *names)
+    return merged.stdout if merged.returncode == 0 else None
+
+
+def _bring_checkout_forward(product_path: str, start: str, end: str) -> None:
+    """Move the checkout to *end*, its development pyproject.toml kept.
+
+    Says so when it cannot, and leaves the checkout exactly as it found it.
+    """
+    hint = f"Your checkout stays where it was. When it can, run git merge --ff-only {end[:12]}."
+    if _git(product_path, "rev-parse", "HEAD").stdout.strip() != start:
+        click.secho(f"  checkout HEAD moved during the release. {hint}", fg="yellow")
+        return
+    pyproject = os.path.join(product_path, PYPROJECT)
+    with open(pyproject, encoding="utf-8") as f:
+        ours = f.read()
+    merged = _merged_pyproject(
+        product_path,
+        ours,
+        _git(product_path, "show", f"{start}:{PYPROJECT}").stdout,
+        _git(product_path, "show", f"{end}:{PYPROJECT}").stdout,
+    )
+    if merged is None:
+        click.secho(
+            f"  checkout your {PYPROJECT} and the release's do not merge. {hint}",
+            fg="yellow",
+        )
+        return
+
+    result = merged
+    moved = False
+    try:
+        _git(product_path, "checkout", "--", PYPROJECT)
+        forward = _git(product_path, "merge", "--ff-only", "--quiet", end)
+        moved = forward.returncode == 0
+        if not moved:
+            result = ours
+            click.secho(
+                f"  checkout {forward.stderr.strip()}\n  checkout {hint}", fg="yellow"
+            )
+    except OSError as e:
+        result = ours
+        click.secho(f"  checkout {e}. {hint}", fg="yellow")
+    finally:
+        with open(pyproject, "w", encoding="utf-8") as f:
+            f.write(result)
+    if moved:
+        click.echo(f"  checkout now at {end[:12]}, your {PYPROJECT} is kept")
+
+
+def run_from_head(
+    product: str, product_path: str, workspace: str, argv: list[str]
+) -> int:
+    """Run this command in a temporary workspace holding HEAD. Its exit code.
+
+    The checkout ends where a release run in it would have, commit included
+    when the command stopped halfway, so release:resume can go on from it.
+    """
+    start = _git(product_path, "rev-parse", "HEAD").stdout.strip()
+    click.secho(
+        f"  checkout {product} has editable features, so this works from what HEAD "
+        f"holds ({start[:12]}).",
+        fg="cyan",
+    )
+    status = _git(product_path, "status", "--porcelain").stdout.splitlines()
+    left_out = [line[3:] for line in status if line[3:] != PYPROJECT]
+    if left_out:
+        click.secho(
+            "  checkout uncommitted, so left out: "
+            + ", ".join(left_out[:5])
+            + (" ..." if len(left_out) > 5 else ""),
+            fg="yellow",
+        )
+
+    settings = settings_left_out(product_path)
+    if settings:
+        click.secho(
+            f"  WARNING  your {PYPROJECT} has settings HEAD does not, so this version "
+            "goes without them. Commit them if production needs them:",
+            fg="yellow",
+            bold=True,
+        )
+        for setting in settings:
+            click.secho(f"           {setting}", fg="yellow")
+
+    temporary = tempfile.mkdtemp(prefix="splent_release_")
+    worktree = os.path.join(temporary, product)
+    try:
+        cache = os.path.join(workspace, ".splent_cache")
+        for path in [cache, *glob.glob(os.path.join(workspace, "splent_spl_*"))]:
+            if os.path.exists(path):
+                os.symlink(path, os.path.join(temporary, os.path.basename(path)))
+        added = _git(product_path, "worktree", "add", "--detach", worktree, start)
+        if added.returncode != 0:
+            click.secho(f"  error: {added.stderr.strip()}", fg="red")
+            return 1
+
+        env = {**os.environ, "WORKING_DIR": temporary, "SPLENT_APP": product}
+        code = _splent(["product:resolve", "--prod", "--strict"], env)
+        if code != 0:
+            return code
+        code = _splent(argv, env)
+
+        end = _git(worktree, "rev-parse", "HEAD").stdout.strip()
+        if end and end != start:
+            _bring_checkout_forward(product_path, start, end)
+        return code
+    finally:
+        _git(product_path, "worktree", "remove", "--force", worktree)
+        _git(product_path, "worktree", "prune")
+        shutil.rmtree(temporary, ignore_errors=True)

{splent_cli-1.51.0 → splent_cli-1.53.0/src/splent_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: splent_cli
-Version: 1.51.0
+Version: 1.53.0
 Summary: SPLENT-CLI is a CLI to be able to work on your development more easily.
 Author-email: DiversoLab <diversolab@us.es>
 License-Expression: LGPL-3.0-or-later

{splent_cli-1.51.0 → splent_cli-1.53.0}/src/splent_cli.egg-info/SOURCES.txt

@@ -186,6 +186,7 @@ src/splent_cli/services/registry.py
 src/splent_cli/services/release.py
 src/splent_cli/services/release_dry_run.py
 src/splent_cli/services/release_gate.py
+src/splent_cli/services/release_workspace.py
 src/splent_cli/services/security_scan.py
 src/splent_cli/services/source_mirror.py
 src/splent_cli/services/spl_store.py