Como posso verificar uma solicitação pull do GitHub com o git?

Gostaria de verificar uma solicitação de recebimento criada anteriormente (criada via interface da web do GitHub). Pesquisei e encontrei lugares diferentes onde um refs / pull ou refs / pull / pr

Mas quando adiciono fetch = +refs/pull/*/head:refs/remotes/origin/pr/*ao arquivo de configuração git e faço uma busca git

O que estou fazendo de errado? O GitHub deve criar automaticamente o material pull / xyz ou preciso configurar algo?

Para buscar um PR remoto em seu repositório local,

git fetch origin pull/ID/head:BRANCHNAME

onde IDé o ID da solicitação de recebimento e BRANCHNAMEé o nome da nova ramificação que você deseja criar. Depois de criar a ramificação, basta

git checkout BRANCHNAME

Veja a documentação oficial do GitHub para mais.

Isso será buscado sem que você precise nomear um ramo:

git pull origin pull/939/head

Como obtenho uma solicitação de recebimento específica na minha máquina?

Essa essência descreve o que aconteceu quando você faz uma busca por git:

Obviamente, altere o URL do github para corresponder ao URL do seu projeto. E acaba assim:

[remote "origin"]
    fetch = +refs/heads/*:refs/remotes/origin/*
    url = git@github.com:joyent/node.git
    fetch = +refs/pull/*/head:refs/remotes/origin/pr/*

Agora, busque todas as solicitações pull:

$ git fetch origin
From github.com:joyent/node
 * [new ref]         refs/pull/1000/head -> origin/pr/1000
 * [new ref]         refs/pull/1002/head -> origin/pr/1002
 * [new ref]         refs/pull/1004/head -> origin/pr/1004
 * [new ref]         refs/pull/1009/head -> origin/pr/1009
...

Para verificar uma solicitação de recebimento específica:

$ git checkout pr/999
Branch pr/999 set up to track remote branch pr/999 from origin.
Switched to a new branch 'pr/999'

Você tem vários scripts listados nos problemas 259 para automatizar essa tarefa.
O projeto git-extras propõe o comando git-pr(implementado no PR 262 )

git-pr(1) - Confira uma solicitação de recebimento localmente

SINOPSE

git-pr <number> [<remote>]
git-pr clean

DESCRIÇÃO

Cria uma ramificação local com base em um número de solicitação de recebimento do GitHub e depois muda para essa ramificação.

O nome do controle remoto para o qual buscar. O padrão é origin.

EXEMPLOS

Isso verifica a solicitação 226de recebimento de origin:

$ git pr 226

remote: Counting objects: 12, done.
remote: Compressing objects: 100% (9/9), done.
remote: Total 12 (delta 3), reused 9 (delta 3)
Unpacking objects: 100% (12/12), done.
From https://github.com/visionmedia/git-extras
  * [new ref] refs/pull/226/head -> pr/226
Switched to branch 'pr/226'

Prefiro buscar e efetuar o checkout sem criar uma filial local e estar no estado destacado HEAD . Ele permite que eu verifique rapidamente a solicitação de recebimento sem poluir minha máquina local com ramificações locais desnecessárias.

git fetch upstream pull/ID/head && git checkout FETCH_HEAD

onde IDé um ID de solicitação de recebimento e upstreamonde a solicitação de recebimento original foi criada (pode ser origin, por exemplo).

Espero que ajude.

Fazendo referência à resposta de Steven Penny, é melhor criar um ramo de teste e testar o PR. Então aqui está o que você faria.

1. Crie uma ramificação de teste para mesclar o PR localmente. Supondo que você esteja no ramo principal:

git checkout -b test

2. Obter as alterações de relações públicas no ramo de teste

git pull origin pull/939/head:test

Agora, você pode testar com segurança as alterações nesse ramo de teste local (neste caso, denominado teste ) e, quando estiver satisfeito, poderá mesclá-lo como de costume no GitHub.

Se você estiver usando o Github.com, vá para "Solicitações de recebimento", clique na solicitação de recebimento relevante e clique no link "instruções da linha de comando":

Você pode usar o git configcomando para escrever uma nova regra .git/configpara buscar solicitações pull do repositório:

$ git config --local --add remote.origin.fetch '+refs/pull/*/head:refs/remotes/origin/pr/*'

E então apenas:

$ git fetch origin
Fetching origin
remote: Counting objects: 4, done.
remote: Compressing objects: 100% (2/2), done.
remote: Total 4 (delta 2), reused 4 (delta 2), pack-reused 0
Unpacking objects: 100% (4/4), done.
From https://github.com/container-images/memcached
 * [new ref]         refs/pull/2/head -> origin/pr/2
 * [new ref]         refs/pull/3/head -> origin/pr/3

O problema com algumas das opções acima é que, se alguém enviar mais confirmações ao PR após abrir o PR, elas não fornecerão a versão mais atualizada. Para mim, o que funcionou melhor - vá para o PR e pressione 'Commits', role para baixo para ver o hash de commit mais recente e, em seguida, simplesmente use git checkout, ou seja,

git checkout <commit number>

no exemplo acima

git checkout 0ba1a50

Estou usando o hub, uma ferramenta do github: https://github.com/github/hub

Com o hub, verificar uma solicitação localmente é meio fácil:

hub checkout https://github.com/owner/repo/pull/1234
or
hub pr checkout 1234

Para Bitbucket, você precisa substituir a palavra pullpara pull-requests.

Primeiro, você pode confirmar o estilo do URL da solicitação de recebimento por git ls-remote origincomando.

$ git ls-remote origin |grep pull
f3f40f2ca9509368c959b0b13729dc0ae2fbf2ae    refs/pull-requests/1503/from
da4666bd91eabcc6f2c214e0bbd99d543d94767e    refs/pull-requests/1503/merge
...

Como você pode ver, é em refs/pull-requests/1503/fromvez derefs/pull/1503/from

Então você pode usar os comandos de qualquer uma das respostas.

Acidentalmente, acabei escrevendo quase o mesmo que o fornecido pelo git-extras. Portanto, se você preferir um único comando personalizado, em vez de instalar vários outros comandos extras, basta colocar esse git-prarquivo em algum lugar no seu $PATHe, em seguida, basta escrever:

git pr 42
// or
git pr upstream 42
// or
git pr https://github.com/peerigon/phridge/pull/1

Se você estiver seguindo o fluxo de trabalho "garfo do github", crie um garfo e adicione o repositório remoto upstream:

14:47 $ git remote -v
origin  git@github.com:<yourname>/<repo_name>.git (fetch)
origin  git@github.com:<yourname>/<repo_name>.git (push)
upstream        git@github.com:<repo_owrer>/<repo_name>.git (fetch)
upstream        git@github.com:<repo_owner>/<repo_name>.git (push)

Para acessar sua ramificação atual, seu comando seria semelhante a:

git pull upstream pull/<pull_request_number>/head

Para entrar em uma nova ramificação, o código seria semelhante a:

git fetch upstream pull/<pull_request_number>/head:newbranch

O Github lançou recentemente um utilitário cli chamado github-cli . Depois de instalá-lo, você pode fazer o checkout local de uma ramificação de solicitação pull usando seu ID

por exemplo: gh pr checkout 2267

Observe que este pacote ainda está na versão beta

Coloque a filial remota do PR na filial local:

git fetch origin ‘remote_branch’:‘local_branch_name’

Defina o upstream da filial local como filial remota.

git branch --set-upstream-to=origin/PR_Branch_Name local_branch

Quando você deseja enviar novamente as alterações locais para a ramificação PR

git push origin HEAD:remote_PR_Branch_name

Suponha que suas informações de origem e upstream sejam como abaixo

   $ git remote -v
   origin  git@github.com:<yourname>/<repo_name>.git (fetch)
   origin  git@github.com:<yourname>/<repo_name>.git (push)
   upstream   git@github.com:<repo_owner>/<repo_name>.git (fetch)
   upstream   git@github.com:<repo_owner>/<repo_name>.git (push)

e o nome do seu ramo é como

   <repo_owner>:<BranchName>

então

   git pull origin <BranchName>

deve fazer o trabalho

Se as confirmações deles estiverem no ramo principal do repositório bifurcado, você poderá fazer o seguinte.

git fetch git@github.com:<repo_owner>/<repo_name>.git
git checkout FETCH_HEAD