park, resume and status find a family folder by family.yaml's name:, but openRepoShape v1.1.0 names it after the holder's repository, so a family whose name differs has no layout that works #236

#!/usr/bin/env python3
"""Reproduce: a family whose display `name:` differs from its repository name.

Usage: exp_family_folder.py <openRepoShape clone> <openRepoTools checkout> <work dir>

For each pin (7f84ca4, 190133d) it builds a holder from that pin's own
family-root files, with family.yaml `name: "QuillWorks"`, `repository:
testorg/Quill` (what `family.py init --family Quill --name QuillWorks`
writes), and one member reached through a local bare remote. Then:

  layout N (folder = name:, what openRepoTools' is_family_folder requires):
      QuillWorks/QuillWorks  -> run the holder's own `make siblings`
  layout R (folder = repository, what openRepoShape v1.1.0 #629 prescribes):
      Quill/Quill            -> run openRepoTools `park Quill --dry-run` and
                                `status Quill`, and the holder's `make siblings`

Nothing here touches the network: every url is a local bare repository.
"""
import os
import shutil
import subprocess
import sys
from pathlib import Path

ORS, ORT, WORK = (Path(p).resolve() for p in sys.argv[1:4])
PINS = {"old": "7f84ca42ca86a8902928345109d2bf6bad87bd91",
        "new": "190133d5e704e380c430f87ca9c4e31746de0012"}
FILE_OK = {"GIT_CONFIG_COUNT": "1", "GIT_CONFIG_KEY_0": "protocol.file.allow",
           "GIT_CONFIG_VALUE_0": "always"}


def env_for(home: Path) -> dict:
    env = {k: v for k, v in os.environ.items()
           if not k.startswith("LANES_") and not k.startswith("TMUX")
           and k not in ("PROJECTS_DIR", "MAKEFLAGS", "MAKELEVEL")}
    env.update(HOME=str(home), PYTHON=sys.executable,
               GIT_AUTHOR_NAME="t", GIT_AUTHOR_EMAIL="t@t.invalid",
               GIT_COMMITTER_NAME="t", GIT_COMMITTER_EMAIL="t@t.invalid",
               **FILE_OK)
    return env


def git(*args, cwd, env=None):
    p = subprocess.run(["git", *args], cwd=str(cwd), capture_output=True,
                       text=True, env=env)
    if p.returncode:
        raise SystemExit(f"git {args} failed in {cwd}:\n{p.stderr}")
    return p.stdout


def show(rev: str, rel: str) -> bytes:
    return subprocess.run(["git", "show", f"{rev}:{rel}"], cwd=str(ORS),
                          capture_output=True, check=True).stdout


def build(base: Path, rev: str, home: Path) -> Path:
    env = env_for(home)
    member = base / "seed" / "Alpha"
    (member / "scripts").mkdir(parents=True)
    (member / "project.yaml").write_text(
        'schema_version: 1\nkind: project-manifest\nid: alpha\nname: "Alpha"\n'
        'tracking_branch: main\nlegs:\n  - role: assembly\n'
        '    repository: testorg/Alpha\n    path: "."\n', encoding="utf-8")
    (member / "scripts" / "bootstrap.py").write_text(
        'print("BOOTSTRAP-Alpha ran")\n', encoding="utf-8")
    git("init", "-q", "-b", "main", ".", cwd=member, env=env)
    git("add", "-A", cwd=member, env=env)
    git("commit", "-qm", "seed", cwd=member, env=env)
    bare = base / "remotes" / "Alpha.git"
    bare.parent.mkdir(parents=True)
    git("clone", "-q", "--bare", str(member), str(bare), cwd=base, env=env)

    holder = base / "seed" / "Quill"
    (holder / "scripts").mkdir(parents=True)
    for rel, dest in (("templates/family-root/Makefile", "Makefile"),
                      ("templates/family-root/.gitignore", ".gitignore"),
                      ("templates/family-root/scripts/bootstrap.py", "scripts/bootstrap.py"),
                      ("templates/family-root/scripts/siblings.py", "scripts/siblings.py"),
                      ("scripts/repo_shape.py", "scripts/repo_shape.py")):
        (holder / dest).write_bytes(show(rev, rel))
    (holder / "family.yaml").write_text(
        'schema_version: 1\nkind: family-manifest\nid: quill\n'
        'name: "QuillWorks"\norg: testorg\nrepository: testorg/Quill\n'
        'tracking_branch: main\nmembers_dir: members\nmembers:\n'
        '  - project: Alpha\n    id: alpha\n    repository: testorg/Alpha\n'
        '    path: members/Alpha\n', encoding="utf-8")
    git("init", "-q", "-b", "main", ".", cwd=holder, env=env)
    git("add", "-A", cwd=holder, env=env)
    git("commit", "-qm", "seed", cwd=holder, env=env)
    git("submodule", "add", "-q", str(bare), "members/Alpha", cwd=holder, env=env)
    git("commit", "-qam", "the member, pinned", cwd=holder, env=env)
    hbare = base / "remotes" / "Quill.git"
    git("clone", "-q", "--bare", str(holder), str(hbare), cwd=base, env=env)
    return hbare


def layout(hbare: Path, home: Path, folder: str) -> Path:
    projects = home / "projects"
    (projects / folder).mkdir(parents=True)
    target = projects / folder / folder
    git("clone", "-q", "--recurse-submodules", str(hbare), str(target),
        cwd=projects, env=env_for(home))
    return target


def run(argv, cwd, home):
    p = subprocess.run(argv, cwd=str(cwd), capture_output=True, text=True,
                       env=env_for(home), input="")
    return p.returncode, p.stdout, p.stderr


def tail(text: str, n: int = 6) -> str:
    lines = [l for l in text.splitlines() if l.strip()]
    return "\n      ".join(lines[-n:])


for label, rev in PINS.items():
    base = WORK / label
    if base.exists():
        shutil.rmtree(base)
    base.mkdir(parents=True)
    print(f"===== pin {label} ({rev[:7]}) =====")
    hbare = build(base, rev, base / "home-build")

    home_n = base / "home-n"
    holder_n = layout(hbare, home_n, "QuillWorks")
    rc, out, err = run(["make", "siblings"], holder_n, home_n)
    placed = (home_n / "projects" / "QuillWorks" / "Alpha" / ".git").exists()
    print(f"  layout N QuillWorks/QuillWorks: `make siblings` exit {rc}; "
          f"member Alpha placed beside the holder: {placed}")
    print(f"      stderr tail: {tail(err, 3)}")

    home_r = base / "home-r"
    holder_r = layout(hbare, home_r, "Quill")
    for cmd in (["bash", str(ORT / "park"), "Quill", "--dry-run"],
                ["bash", str(ORT / "status"), "Quill"]):
        rc, out, err = run(cmd, home_r, home_r)
        print(f"  layout R Quill/Quill: `{Path(cmd[1]).name} {' '.join(cmd[2:])}` "
              f"exit {rc}: {tail(err or out, 2)}")
    rc, out, err = run(["make", "siblings"], holder_r, home_r)
    placed = (home_r / "projects" / "Quill" / "Alpha" / ".git").exists()
    print(f"  layout R Quill/Quill: `make siblings` exit {rc}; member Alpha "
          f"placed: {placed}")