How do I checkout a checkout a github pull request

[Mic92]

With git I can do git fetch upstream refs/pull/374615/head, but jujutsu fails on the same operation:

jj git fetch --remote upstream  --branch refs/pull/374615/head
Warning: No branch matching `refs/pull/374615/head` found on any specified/configured remote
Nothing changed.

[jennings]

I believe jj always fetches from refs/heads/* on the remote, so I don't think there is any way to do this with jj alone.

If your repo is colocated, you can use git to fetch these branches.

[Mic92]

Do people have some scripts around this? Usually I use hub checkout to get a pull request and it also allows me to push to a pr. But when I run jj this association gets removed again.

[jennings]

I don’t know about scripts, but if hub creates a local branch, you should be able to do everything to it with jj except push and pull.

[Mic92]

So when I check out a pull request:

hub checkout https://github.com/NixOS/nixpkgs/pull/374620

Hub does this:

# .git/config
[branch "patch-1"]
	remote = https://github.com/nmouha/nixpkgs.git
	merge = refs/heads/patch-1

For this to work jj always needs to match the right branch that git created on checkout.
This seems to do the job to move the git branch to the current HEAD again.

jj bookmark move --from 'heads(::@- & bookmarks())' --to @-

[Mic92]

Potentially a better integration would just use .git/config instead to instruct jj to fetch it directly because switching between git and jj in large repositories seems a bit slow.

[martinvonz]

We have #4388 for pushing and fetching specific refs. We might get some forge-specific integrations some day (e.g. #4555 for GitHub integration).

[Mic92]

I wrote some script to create local branches/checkouts and manages remotes

$ jj-pr checkout 328442

#!/usr/bin/env python3

import json
import subprocess
import argparse
import shlex
from dataclasses import dataclass


@dataclass
class PullRequest:
    head_repository: str
    head_ref_name: str
    head_repository_owner: str

    def remote_url(self) -> str:
        return f"[email protected]:{self.head_repository_owner}/{self.head_repository}.git"


def get_pull_request(pull_request: int) -> PullRequest:
    output = subprocess.run(
        [
            "gh",
            "pr",
            "view",
            "--json",
            "headRepository,headRefName,headRepositoryOwner",
            str(pull_request),
        ],
        text=True,
        check=True,
        stdout=subprocess.PIPE,
    )
    data = json.loads(output.stdout)
    return PullRequest(
        head_repository=data["headRepository"]["name"],
        head_ref_name=data["headRefName"],
        head_repository_owner=data["headRepositoryOwner"]["login"],
    )


def add_or_set_remote(remote_name: str, remote_url: str) -> None:
    command = ["jj", "git", "remote", "add", remote_name, remote_url]
    try:
        subprocess.run(
            command,
            check=True,
        )
    except subprocess.CalledProcessError:
        command = ["jj", "git", "remote", "set-url", remote_name, remote_url]
        print("$ " + " ".join(map(shlex.quote, command)))
        subprocess.run(
            command,
            check=True,
        )


def checkout_command(args: argparse.Namespace) -> None:
    pr_number: int = args.pull_request
    pull_request = get_pull_request(pr_number)
    add_or_set_remote(pull_request.head_repository_owner, pull_request.remote_url())
    command = [
        "jj",
        "git",
        "fetch",
        "--remote",
        pull_request.head_repository_owner,
        "--branch",
        pull_request.head_ref_name,
    ]
    print("$ " + " ".join(map(shlex.quote, command)))
    subprocess.run(
        command,
        check=True,
    )
    command = [
        "jj",
        "new",
        f"{pull_request.head_ref_name}@{pull_request.head_repository_owner}",
    ]
    subprocess.run(
        command,
        check=True,
    )


def parse_args() -> argparse.Namespace:
    parser = argparse.ArgumentParser(
        description="Checkout the a pull request locally with jj."
    )
    subparsers = parser.add_subparsers(dest="subcommand")
    subparsers.required = True
    checkout = subparsers.add_parser("checkout", help="")
    checkout.add_argument("pull_request", type=int, help="The pull request number")
    checkout.set_defaults(func=checkout_command)
    return parser.parse_args()


def main() -> None:
    parsed_args = parse_args()
    parsed_args.func(parsed_args)


if __name__ == "__main__":
    main()

However a lot of other functionality in jj is not yet clear to me (how this merge conflict editor works etc). Will test this in a few months again and see if things clear up.

[ilyagr]

Not sure if this is helpful, but I personally still use Git in colocated repos for this.

I like this alias (which does exactly the git fetch operation you mentioned, and also creates a pr/1234 branch for the result of the fetch):

# ~/.config/git/config
[aliases]
# Simplified from https://gist.github.com/gnarf/5406589
pr  = "!f() { git fetch -fu ${2:-$(git remote |grep ^upstream || echo origin)} refs/pull/$1/head:pr/$1 }; f"

The original script also put ; git checkout $1 inside the function but I don't like that, especially when using it with jj.

The usage is simply git pr 1234.

[Mic92]

That kinds of works but it doesn't allow you to push, which my script above make sure works. But the downside is that in a busy repository you end up with a lot of remotes.